001// Generated from com/puppycrawl/tools/checkstyle/grammars/javadoc/JavadocParser.g4 by ANTLR 4.5.2 002package com.puppycrawl.tools.checkstyle.grammars.javadoc; 003import org.antlr.v4.runtime.atn.*; 004import org.antlr.v4.runtime.dfa.DFA; 005import org.antlr.v4.runtime.*; 006import org.antlr.v4.runtime.misc.*; 007import org.antlr.v4.runtime.tree.*; 008import java.util.List; 009import java.util.Iterator; 010import java.util.ArrayList; 011 012@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) 013public class JavadocParser extends Parser { 014 static { RuntimeMetaData.checkVersion("4.5.2", RuntimeMetaData.VERSION); } 015 016 protected static final DFA[] _decisionToDFA; 017 protected static final PredictionContextCache _sharedContextCache = 018 new PredictionContextCache(); 019 public static final int 020 LEADING_ASTERISK=1, HTML_COMMENT_START=2, CDATA=3, WS=4, OPEN=5, NEWLINE=6, 021 AUTHOR_LITERAL=7, DEPRECATED_LITERAL=8, EXCEPTION_LITERAL=9, PARAM_LITERAL=10, 022 RETURN_LITERAL=11, SEE_LITERAL=12, SERIAL_LITERAL=13, SERIAL_FIELD_LITERAL=14, 023 SERIAL_DATA_LITERAL=15, SINCE_LITERAL=16, THROWS_LITERAL=17, VERSION_LITERAL=18, 024 JAVADOC_INLINE_TAG_START=19, JAVADOC_INLINE_TAG_END=20, CUSTOM_NAME=21, 025 LITERAL_INCLUDE=22, LITERAL_EXCLUDE=23, CHAR=24, PARAMETER_NAME=25, Char1=26, 026 STRING=27, PACKAGE=28, DOT=29, HASH=30, CLASS=31, Char2=32, MEMBER=33, 027 LEFT_BRACE=34, RIGHT_BRACE=35, ARGUMENT=36, COMMA=37, Char20=38, FIELD_NAME=39, 028 Char3=40, FIELD_TYPE=41, Char4=42, CLASS_NAME=43, Char5=44, CODE_LITERAL=45, 029 DOC_ROOT_LITERAL=46, INHERIT_DOC_LITERAL=47, LINK_LITERAL=48, LINKPLAIN_LITERAL=49, 030 LITERAL_LITERAL=50, VALUE_LITERAL=51, Char7=52, Char8=53, Char10=54, CLOSE=55, 031 SLASH_CLOSE=56, SLASH=57, EQUALS=58, P_HTML_TAG_NAME=59, LI_HTML_TAG_NAME=60, 032 TR_HTML_TAG_NAME=61, TD_HTML_TAG_NAME=62, TH_HTML_TAG_NAME=63, BODY_HTML_TAG_NAME=64, 033 COLGROUP_HTML_TAG_NAME=65, DD_HTML_TAG_NAME=66, DT_HTML_TAG_NAME=67, HEAD_HTML_TAG_NAME=68, 034 HTML_HTML_TAG_NAME=69, OPTION_HTML_TAG_NAME=70, TBODY_HTML_TAG_NAME=71, 035 TFOOT_HTML_TAG_NAME=72, THEAD_HTML_TAG_NAME=73, AREA_HTML_TAG_NAME=74, 036 BASE_HTML_TAG_NAME=75, BASEFRONT_HTML_TAG_NAME=76, BR_HTML_TAG_NAME=77, 037 COL_HTML_TAG_NAME=78, FRAME_HTML_TAG_NAME=79, HR_HTML_TAG_NAME=80, IMG_HTML_TAG_NAME=81, 038 INPUT_HTML_TAG_NAME=82, ISINDEX_HTML_TAG_NAME=83, LINK_HTML_TAG_NAME=84, 039 META_HTML_TAG_NAME=85, PARAM_HTML_TAG_NAME=86, HTML_TAG_NAME=87, Char11=88, 040 ATTR_VALUE=89, Char12=90, HTML_COMMENT_END=91; 041 public static final int 042 RULE_javadoc = 0, RULE_htmlElement = 1, RULE_htmlElementOpen = 2, RULE_htmlElementClose = 3, 043 RULE_attribute = 4, RULE_htmlTag = 5, RULE_pTagOpen = 6, RULE_pTagClose = 7, 044 RULE_paragraph = 8, RULE_liTagOpen = 9, RULE_liTagClose = 10, RULE_li = 11, 045 RULE_trTagOpen = 12, RULE_trTagClose = 13, RULE_tr = 14, RULE_tdTagOpen = 15, 046 RULE_tdTagClose = 16, RULE_td = 17, RULE_thTagOpen = 18, RULE_thTagClose = 19, 047 RULE_th = 20, RULE_bodyTagOpen = 21, RULE_bodyTagClose = 22, RULE_body = 23, 048 RULE_colgroupTagOpen = 24, RULE_colgroupTagClose = 25, RULE_colgroup = 26, 049 RULE_ddTagOpen = 27, RULE_ddTagClose = 28, RULE_dd = 29, RULE_dtTagOpen = 30, 050 RULE_dtTagClose = 31, RULE_dt = 32, RULE_headTagOpen = 33, RULE_headTagClose = 34, 051 RULE_head = 35, RULE_htmlTagOpen = 36, RULE_htmlTagClose = 37, RULE_html = 38, 052 RULE_optionTagOpen = 39, RULE_optionTagClose = 40, RULE_option = 41, RULE_tbodyTagOpen = 42, 053 RULE_tbodyTagClose = 43, RULE_tbody = 44, RULE_tfootTagOpen = 45, RULE_tfootTagClose = 46, 054 RULE_tfoot = 47, RULE_theadTagOpen = 48, RULE_theadTagClose = 49, RULE_thead = 50, 055 RULE_singletonElement = 51, RULE_singletonTag = 52, RULE_areaTag = 53, 056 RULE_baseTag = 54, RULE_basefrontTag = 55, RULE_brTag = 56, RULE_colTag = 57, 057 RULE_frameTag = 58, RULE_hrTag = 59, RULE_imgTag = 60, RULE_inputTag = 61, 058 RULE_isindexTag = 62, RULE_linkTag = 63, RULE_metaTag = 64, RULE_paramTag = 65, 059 RULE_wrongSinletonTag = 66, RULE_singletonTagName = 67, RULE_description = 68, 060 RULE_reference = 69, RULE_parameters = 70, RULE_javadocTag = 71, RULE_javadocInlineTag = 72, 061 RULE_htmlComment = 73, RULE_text = 74; 062 public static final String[] ruleNames = { 063 "javadoc", "htmlElement", "htmlElementOpen", "htmlElementClose", "attribute", 064 "htmlTag", "pTagOpen", "pTagClose", "paragraph", "liTagOpen", "liTagClose", 065 "li", "trTagOpen", "trTagClose", "tr", "tdTagOpen", "tdTagClose", "td", 066 "thTagOpen", "thTagClose", "th", "bodyTagOpen", "bodyTagClose", "body", 067 "colgroupTagOpen", "colgroupTagClose", "colgroup", "ddTagOpen", "ddTagClose", 068 "dd", "dtTagOpen", "dtTagClose", "dt", "headTagOpen", "headTagClose", 069 "head", "htmlTagOpen", "htmlTagClose", "html", "optionTagOpen", "optionTagClose", 070 "option", "tbodyTagOpen", "tbodyTagClose", "tbody", "tfootTagOpen", "tfootTagClose", 071 "tfoot", "theadTagOpen", "theadTagClose", "thead", "singletonElement", 072 "singletonTag", "areaTag", "baseTag", "basefrontTag", "brTag", "colTag", 073 "frameTag", "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", 074 "paramTag", "wrongSinletonTag", "singletonTagName", "description", "reference", 075 "parameters", "javadocTag", "javadocInlineTag", "htmlComment", "text" 076 }; 077 078 private static final String[] _LITERAL_NAMES = { 079 null, null, null, null, null, null, null, "'@author'", "'@deprecated'", 080 null, null, "'@return'", null, "'@serial'", null, "'@serialData'", "'@since'", 081 null, "'@version'", null, null, null, "'include'", "'exclude'", null, 082 null, null, null, null, "'.'", null, null, null, null, "'('", "')'", null, 083 "','", null, null, null, null, null, null, null, null, "'@docRoot'", "'@inheritDoc'", 084 "'@link'", "'@linkplain'", null, "'@value'", null, null, null, null, null, 085 "'/'", "'='", null, null, null, null, null, null, null, null, null, null, 086 null, null, null, null, null, null, null, null, null, null, null, null, 087 null, null, null, null, null, null, null, null, null, null, "'-->'" 088 }; 089 private static final String[] _SYMBOLIC_NAMES = { 090 null, "LEADING_ASTERISK", "HTML_COMMENT_START", "CDATA", "WS", "OPEN", 091 "NEWLINE", "AUTHOR_LITERAL", "DEPRECATED_LITERAL", "EXCEPTION_LITERAL", 092 "PARAM_LITERAL", "RETURN_LITERAL", "SEE_LITERAL", "SERIAL_LITERAL", "SERIAL_FIELD_LITERAL", 093 "SERIAL_DATA_LITERAL", "SINCE_LITERAL", "THROWS_LITERAL", "VERSION_LITERAL", 094 "JAVADOC_INLINE_TAG_START", "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", "LITERAL_INCLUDE", 095 "LITERAL_EXCLUDE", "CHAR", "PARAMETER_NAME", "Char1", "STRING", "PACKAGE", 096 "DOT", "HASH", "CLASS", "Char2", "MEMBER", "LEFT_BRACE", "RIGHT_BRACE", 097 "ARGUMENT", "COMMA", "Char20", "FIELD_NAME", "Char3", "FIELD_TYPE", "Char4", 098 "CLASS_NAME", "Char5", "CODE_LITERAL", "DOC_ROOT_LITERAL", "INHERIT_DOC_LITERAL", 099 "LINK_LITERAL", "LINKPLAIN_LITERAL", "LITERAL_LITERAL", "VALUE_LITERAL", 100 "Char7", "Char8", "Char10", "CLOSE", "SLASH_CLOSE", "SLASH", "EQUALS", 101 "P_HTML_TAG_NAME", "LI_HTML_TAG_NAME", "TR_HTML_TAG_NAME", "TD_HTML_TAG_NAME", 102 "TH_HTML_TAG_NAME", "BODY_HTML_TAG_NAME", "COLGROUP_HTML_TAG_NAME", "DD_HTML_TAG_NAME", 103 "DT_HTML_TAG_NAME", "HEAD_HTML_TAG_NAME", "HTML_HTML_TAG_NAME", "OPTION_HTML_TAG_NAME", 104 "TBODY_HTML_TAG_NAME", "TFOOT_HTML_TAG_NAME", "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", 105 "BASE_HTML_TAG_NAME", "BASEFRONT_HTML_TAG_NAME", "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", 106 "FRAME_HTML_TAG_NAME", "HR_HTML_TAG_NAME", "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", 107 "ISINDEX_HTML_TAG_NAME", "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", 108 "HTML_TAG_NAME", "Char11", "ATTR_VALUE", "Char12", "HTML_COMMENT_END" 109 }; 110 public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); 111 112 /** 113 * @deprecated Use {@link #VOCABULARY} instead. 114 */ 115 @Deprecated 116 public static final String[] tokenNames; 117 static { 118 tokenNames = new String[_SYMBOLIC_NAMES.length]; 119 for (int i = 0; i < tokenNames.length; i++) { 120 tokenNames[i] = VOCABULARY.getLiteralName(i); 121 if (tokenNames[i] == null) { 122 tokenNames[i] = VOCABULARY.getSymbolicName(i); 123 } 124 125 if (tokenNames[i] == null) { 126 tokenNames[i] = "<INVALID>"; 127 } 128 } 129 } 130 131 @Override 132 @Deprecated 133 public String[] getTokenNames() { 134 return tokenNames; 135 } 136 137 @Override 138 139 public Vocabulary getVocabulary() { 140 return VOCABULARY; 141 } 142 143 @Override 144 public String getGrammarFileName() { return "JavadocParser.g4"; } 145 146 @Override 147 public String[] getRuleNames() { return ruleNames; } 148 149 @Override 150 public String getSerializedATN() { return _serializedATN; } 151 152 @Override 153 public ATN getATN() { return _ATN; } 154 155 156 boolean isNextJavadocTag() { 157 int token1 = _input.LA(2); 158 int token2 = _input.LA(3); 159 return isJavadocTag(token1) 160 || (token1 == WS && isJavadocTag(token2)); 161 } 162 163 boolean isJavadocTag(int type) { 164 switch(type) { 165 case AUTHOR_LITERAL: 166 case DEPRECATED_LITERAL: 167 case EXCEPTION_LITERAL: 168 case PARAM_LITERAL: 169 case RETURN_LITERAL: 170 case SEE_LITERAL: 171 case SERIAL_LITERAL: 172 case SERIAL_FIELD_LITERAL: 173 case SERIAL_DATA_LITERAL: 174 case SINCE_LITERAL: 175 case THROWS_LITERAL: 176 case VERSION_LITERAL: 177 case CUSTOM_NAME: 178 return true; 179 default: 180 return false; 181 } 182 } 183 184 boolean isSameTagNames(ParserRuleContext htmlTagOpen, ParserRuleContext htmlTagClose) { 185 String openTag = htmlTagOpen.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 186 String closeTag = htmlTagClose.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 187 System.out.println(openTag + " - " + closeTag); 188 return openTag.equals(closeTag); 189 } 190 191 public JavadocParser(TokenStream input) { 192 super(input); 193 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); 194 } 195 public static class JavadocContext extends ParserRuleContext { 196 public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); } 197 public List<HtmlElementContext> htmlElement() { 198 return getRuleContexts(HtmlElementContext.class); 199 } 200 public HtmlElementContext htmlElement(int i) { 201 return getRuleContext(HtmlElementContext.class,i); 202 } 203 public List<HtmlCommentContext> htmlComment() { 204 return getRuleContexts(HtmlCommentContext.class); 205 } 206 public HtmlCommentContext htmlComment(int i) { 207 return getRuleContext(HtmlCommentContext.class,i); 208 } 209 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 210 public TerminalNode CDATA(int i) { 211 return getToken(JavadocParser.CDATA, i); 212 } 213 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 214 public TerminalNode NEWLINE(int i) { 215 return getToken(JavadocParser.NEWLINE, i); 216 } 217 public List<TextContext> text() { 218 return getRuleContexts(TextContext.class); 219 } 220 public TextContext text(int i) { 221 return getRuleContext(TextContext.class,i); 222 } 223 public List<JavadocInlineTagContext> javadocInlineTag() { 224 return getRuleContexts(JavadocInlineTagContext.class); 225 } 226 public JavadocInlineTagContext javadocInlineTag(int i) { 227 return getRuleContext(JavadocInlineTagContext.class,i); 228 } 229 public List<JavadocTagContext> javadocTag() { 230 return getRuleContexts(JavadocTagContext.class); 231 } 232 public JavadocTagContext javadocTag(int i) { 233 return getRuleContext(JavadocTagContext.class,i); 234 } 235 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 236 public TerminalNode LEADING_ASTERISK(int i) { 237 return getToken(JavadocParser.LEADING_ASTERISK, i); 238 } 239 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 240 public TerminalNode WS(int i) { 241 return getToken(JavadocParser.WS, i); 242 } 243 public JavadocContext(ParserRuleContext parent, int invokingState) { 244 super(parent, invokingState); 245 } 246 @Override public int getRuleIndex() { return RULE_javadoc; } 247 @Override 248 public void enterRule(ParseTreeListener listener) { 249 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadoc(this); 250 } 251 @Override 252 public void exitRule(ParseTreeListener listener) { 253 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadoc(this); 254 } 255 @Override 256 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 257 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadoc(this); 258 else return visitor.visitChildren(this); 259 } 260 } 261 262 public final JavadocContext javadoc() throws RecognitionException { 263 JavadocContext _localctx = new JavadocContext(_ctx, getState()); 264 enterRule(_localctx, 0, RULE_javadoc); 265 int _la; 266 try { 267 int _alt; 268 enterOuterAlt(_localctx, 1); 269 { 270 setState(160); 271 _errHandler.sync(this); 272 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 273 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 274 if ( _alt==1 ) { 275 { 276 setState(158); 277 _errHandler.sync(this); 278 switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { 279 case 1: 280 { 281 setState(150); 282 htmlElement(); 283 } 284 break; 285 case 2: 286 { 287 { 288 setState(151); 289 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 290 setState(152); 291 match(LEADING_ASTERISK); 292 } 293 } 294 break; 295 case 3: 296 { 297 setState(153); 298 htmlComment(); 299 } 300 break; 301 case 4: 302 { 303 setState(154); 304 match(CDATA); 305 } 306 break; 307 case 5: 308 { 309 setState(155); 310 match(NEWLINE); 311 } 312 break; 313 case 6: 314 { 315 setState(156); 316 text(); 317 } 318 break; 319 case 7: 320 { 321 setState(157); 322 javadocInlineTag(); 323 } 324 break; 325 } 326 } 327 } 328 setState(162); 329 _errHandler.sync(this); 330 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 331 } 332 setState(175); 333 _errHandler.sync(this); 334 _la = _input.LA(1); 335 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)) { 336 { 337 { 338 setState(164); 339 _la = _input.LA(1); 340 if (_la==LEADING_ASTERISK) { 341 { 342 setState(163); 343 match(LEADING_ASTERISK); 344 } 345 } 346 347 setState(169); 348 _errHandler.sync(this); 349 _la = _input.LA(1); 350 while (_la==WS) { 351 { 352 { 353 setState(166); 354 match(WS); 355 } 356 } 357 setState(171); 358 _errHandler.sync(this); 359 _la = _input.LA(1); 360 } 361 setState(172); 362 javadocTag(); 363 } 364 } 365 setState(177); 366 _errHandler.sync(this); 367 _la = _input.LA(1); 368 } 369 setState(178); 370 match(EOF); 371 } 372 } 373 catch (RecognitionException re) { 374 _localctx.exception = re; 375 _errHandler.reportError(this, re); 376 _errHandler.recover(this, re); 377 } 378 finally { 379 exitRule(); 380 } 381 return _localctx; 382 } 383 384 public static class HtmlElementContext extends ParserRuleContext { 385 public HtmlTagContext htmlTag() { 386 return getRuleContext(HtmlTagContext.class,0); 387 } 388 public SingletonElementContext singletonElement() { 389 return getRuleContext(SingletonElementContext.class,0); 390 } 391 public ParagraphContext paragraph() { 392 return getRuleContext(ParagraphContext.class,0); 393 } 394 public LiContext li() { 395 return getRuleContext(LiContext.class,0); 396 } 397 public TrContext tr() { 398 return getRuleContext(TrContext.class,0); 399 } 400 public TdContext td() { 401 return getRuleContext(TdContext.class,0); 402 } 403 public ThContext th() { 404 return getRuleContext(ThContext.class,0); 405 } 406 public BodyContext body() { 407 return getRuleContext(BodyContext.class,0); 408 } 409 public ColgroupContext colgroup() { 410 return getRuleContext(ColgroupContext.class,0); 411 } 412 public DdContext dd() { 413 return getRuleContext(DdContext.class,0); 414 } 415 public DtContext dt() { 416 return getRuleContext(DtContext.class,0); 417 } 418 public HeadContext head() { 419 return getRuleContext(HeadContext.class,0); 420 } 421 public HtmlContext html() { 422 return getRuleContext(HtmlContext.class,0); 423 } 424 public OptionContext option() { 425 return getRuleContext(OptionContext.class,0); 426 } 427 public TbodyContext tbody() { 428 return getRuleContext(TbodyContext.class,0); 429 } 430 public TheadContext thead() { 431 return getRuleContext(TheadContext.class,0); 432 } 433 public TfootContext tfoot() { 434 return getRuleContext(TfootContext.class,0); 435 } 436 public PTagOpenContext pTagOpen() { 437 return getRuleContext(PTagOpenContext.class,0); 438 } 439 public LiTagOpenContext liTagOpen() { 440 return getRuleContext(LiTagOpenContext.class,0); 441 } 442 public TrTagOpenContext trTagOpen() { 443 return getRuleContext(TrTagOpenContext.class,0); 444 } 445 public TdTagOpenContext tdTagOpen() { 446 return getRuleContext(TdTagOpenContext.class,0); 447 } 448 public ThTagOpenContext thTagOpen() { 449 return getRuleContext(ThTagOpenContext.class,0); 450 } 451 public BodyTagOpenContext bodyTagOpen() { 452 return getRuleContext(BodyTagOpenContext.class,0); 453 } 454 public ColgroupTagOpenContext colgroupTagOpen() { 455 return getRuleContext(ColgroupTagOpenContext.class,0); 456 } 457 public DdTagOpenContext ddTagOpen() { 458 return getRuleContext(DdTagOpenContext.class,0); 459 } 460 public DtTagOpenContext dtTagOpen() { 461 return getRuleContext(DtTagOpenContext.class,0); 462 } 463 public HeadTagOpenContext headTagOpen() { 464 return getRuleContext(HeadTagOpenContext.class,0); 465 } 466 public HtmlTagOpenContext htmlTagOpen() { 467 return getRuleContext(HtmlTagOpenContext.class,0); 468 } 469 public OptionTagOpenContext optionTagOpen() { 470 return getRuleContext(OptionTagOpenContext.class,0); 471 } 472 public TbodyTagOpenContext tbodyTagOpen() { 473 return getRuleContext(TbodyTagOpenContext.class,0); 474 } 475 public TheadTagOpenContext theadTagOpen() { 476 return getRuleContext(TheadTagOpenContext.class,0); 477 } 478 public TfootTagOpenContext tfootTagOpen() { 479 return getRuleContext(TfootTagOpenContext.class,0); 480 } 481 public PTagCloseContext pTagClose() { 482 return getRuleContext(PTagCloseContext.class,0); 483 } 484 public LiTagCloseContext liTagClose() { 485 return getRuleContext(LiTagCloseContext.class,0); 486 } 487 public TrTagCloseContext trTagClose() { 488 return getRuleContext(TrTagCloseContext.class,0); 489 } 490 public TdTagCloseContext tdTagClose() { 491 return getRuleContext(TdTagCloseContext.class,0); 492 } 493 public ThTagCloseContext thTagClose() { 494 return getRuleContext(ThTagCloseContext.class,0); 495 } 496 public BodyTagCloseContext bodyTagClose() { 497 return getRuleContext(BodyTagCloseContext.class,0); 498 } 499 public ColgroupTagCloseContext colgroupTagClose() { 500 return getRuleContext(ColgroupTagCloseContext.class,0); 501 } 502 public DdTagCloseContext ddTagClose() { 503 return getRuleContext(DdTagCloseContext.class,0); 504 } 505 public DtTagCloseContext dtTagClose() { 506 return getRuleContext(DtTagCloseContext.class,0); 507 } 508 public HeadTagCloseContext headTagClose() { 509 return getRuleContext(HeadTagCloseContext.class,0); 510 } 511 public HtmlTagCloseContext htmlTagClose() { 512 return getRuleContext(HtmlTagCloseContext.class,0); 513 } 514 public OptionTagCloseContext optionTagClose() { 515 return getRuleContext(OptionTagCloseContext.class,0); 516 } 517 public TbodyTagCloseContext tbodyTagClose() { 518 return getRuleContext(TbodyTagCloseContext.class,0); 519 } 520 public TheadTagCloseContext theadTagClose() { 521 return getRuleContext(TheadTagCloseContext.class,0); 522 } 523 public TfootTagCloseContext tfootTagClose() { 524 return getRuleContext(TfootTagCloseContext.class,0); 525 } 526 public HtmlElementContext(ParserRuleContext parent, int invokingState) { 527 super(parent, invokingState); 528 } 529 @Override public int getRuleIndex() { return RULE_htmlElement; } 530 @Override 531 public void enterRule(ParseTreeListener listener) { 532 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElement(this); 533 } 534 @Override 535 public void exitRule(ParseTreeListener listener) { 536 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElement(this); 537 } 538 @Override 539 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 540 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElement(this); 541 else return visitor.visitChildren(this); 542 } 543 } 544 545 public final HtmlElementContext htmlElement() throws RecognitionException { 546 HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState()); 547 enterRule(_localctx, 2, RULE_htmlElement); 548 try { 549 setState(227); 550 _errHandler.sync(this); 551 switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { 552 case 1: 553 enterOuterAlt(_localctx, 1); 554 { 555 setState(180); 556 htmlTag(); 557 } 558 break; 559 case 2: 560 enterOuterAlt(_localctx, 2); 561 { 562 setState(181); 563 singletonElement(); 564 } 565 break; 566 case 3: 567 enterOuterAlt(_localctx, 3); 568 { 569 setState(182); 570 paragraph(); 571 } 572 break; 573 case 4: 574 enterOuterAlt(_localctx, 4); 575 { 576 setState(183); 577 li(); 578 } 579 break; 580 case 5: 581 enterOuterAlt(_localctx, 5); 582 { 583 setState(184); 584 tr(); 585 } 586 break; 587 case 6: 588 enterOuterAlt(_localctx, 6); 589 { 590 setState(185); 591 td(); 592 } 593 break; 594 case 7: 595 enterOuterAlt(_localctx, 7); 596 { 597 setState(186); 598 th(); 599 } 600 break; 601 case 8: 602 enterOuterAlt(_localctx, 8); 603 { 604 setState(187); 605 body(); 606 } 607 break; 608 case 9: 609 enterOuterAlt(_localctx, 9); 610 { 611 setState(188); 612 colgroup(); 613 } 614 break; 615 case 10: 616 enterOuterAlt(_localctx, 10); 617 { 618 setState(189); 619 dd(); 620 } 621 break; 622 case 11: 623 enterOuterAlt(_localctx, 11); 624 { 625 setState(190); 626 dt(); 627 } 628 break; 629 case 12: 630 enterOuterAlt(_localctx, 12); 631 { 632 setState(191); 633 head(); 634 } 635 break; 636 case 13: 637 enterOuterAlt(_localctx, 13); 638 { 639 setState(192); 640 html(); 641 } 642 break; 643 case 14: 644 enterOuterAlt(_localctx, 14); 645 { 646 setState(193); 647 option(); 648 } 649 break; 650 case 15: 651 enterOuterAlt(_localctx, 15); 652 { 653 setState(194); 654 tbody(); 655 } 656 break; 657 case 16: 658 enterOuterAlt(_localctx, 16); 659 { 660 setState(195); 661 thead(); 662 } 663 break; 664 case 17: 665 enterOuterAlt(_localctx, 17); 666 { 667 setState(196); 668 tfoot(); 669 } 670 break; 671 case 18: 672 enterOuterAlt(_localctx, 18); 673 { 674 setState(197); 675 pTagOpen(); 676 } 677 break; 678 case 19: 679 enterOuterAlt(_localctx, 19); 680 { 681 setState(198); 682 liTagOpen(); 683 } 684 break; 685 case 20: 686 enterOuterAlt(_localctx, 20); 687 { 688 setState(199); 689 trTagOpen(); 690 } 691 break; 692 case 21: 693 enterOuterAlt(_localctx, 21); 694 { 695 setState(200); 696 tdTagOpen(); 697 } 698 break; 699 case 22: 700 enterOuterAlt(_localctx, 22); 701 { 702 setState(201); 703 thTagOpen(); 704 } 705 break; 706 case 23: 707 enterOuterAlt(_localctx, 23); 708 { 709 setState(202); 710 bodyTagOpen(); 711 } 712 break; 713 case 24: 714 enterOuterAlt(_localctx, 24); 715 { 716 setState(203); 717 colgroupTagOpen(); 718 } 719 break; 720 case 25: 721 enterOuterAlt(_localctx, 25); 722 { 723 setState(204); 724 ddTagOpen(); 725 } 726 break; 727 case 26: 728 enterOuterAlt(_localctx, 26); 729 { 730 setState(205); 731 dtTagOpen(); 732 } 733 break; 734 case 27: 735 enterOuterAlt(_localctx, 27); 736 { 737 setState(206); 738 headTagOpen(); 739 } 740 break; 741 case 28: 742 enterOuterAlt(_localctx, 28); 743 { 744 setState(207); 745 htmlTagOpen(); 746 } 747 break; 748 case 29: 749 enterOuterAlt(_localctx, 29); 750 { 751 setState(208); 752 optionTagOpen(); 753 } 754 break; 755 case 30: 756 enterOuterAlt(_localctx, 30); 757 { 758 setState(209); 759 tbodyTagOpen(); 760 } 761 break; 762 case 31: 763 enterOuterAlt(_localctx, 31); 764 { 765 setState(210); 766 theadTagOpen(); 767 } 768 break; 769 case 32: 770 enterOuterAlt(_localctx, 32); 771 { 772 setState(211); 773 tfootTagOpen(); 774 } 775 break; 776 case 33: 777 enterOuterAlt(_localctx, 33); 778 { 779 setState(212); 780 pTagClose(); 781 } 782 break; 783 case 34: 784 enterOuterAlt(_localctx, 34); 785 { 786 setState(213); 787 liTagClose(); 788 } 789 break; 790 case 35: 791 enterOuterAlt(_localctx, 35); 792 { 793 setState(214); 794 trTagClose(); 795 } 796 break; 797 case 36: 798 enterOuterAlt(_localctx, 36); 799 { 800 setState(215); 801 tdTagClose(); 802 } 803 break; 804 case 37: 805 enterOuterAlt(_localctx, 37); 806 { 807 setState(216); 808 thTagClose(); 809 } 810 break; 811 case 38: 812 enterOuterAlt(_localctx, 38); 813 { 814 setState(217); 815 bodyTagClose(); 816 } 817 break; 818 case 39: 819 enterOuterAlt(_localctx, 39); 820 { 821 setState(218); 822 colgroupTagClose(); 823 } 824 break; 825 case 40: 826 enterOuterAlt(_localctx, 40); 827 { 828 setState(219); 829 ddTagClose(); 830 } 831 break; 832 case 41: 833 enterOuterAlt(_localctx, 41); 834 { 835 setState(220); 836 dtTagClose(); 837 } 838 break; 839 case 42: 840 enterOuterAlt(_localctx, 42); 841 { 842 setState(221); 843 headTagClose(); 844 } 845 break; 846 case 43: 847 enterOuterAlt(_localctx, 43); 848 { 849 setState(222); 850 htmlTagClose(); 851 } 852 break; 853 case 44: 854 enterOuterAlt(_localctx, 44); 855 { 856 setState(223); 857 optionTagClose(); 858 } 859 break; 860 case 45: 861 enterOuterAlt(_localctx, 45); 862 { 863 setState(224); 864 tbodyTagClose(); 865 } 866 break; 867 case 46: 868 enterOuterAlt(_localctx, 46); 869 { 870 setState(225); 871 theadTagClose(); 872 } 873 break; 874 case 47: 875 enterOuterAlt(_localctx, 47); 876 { 877 setState(226); 878 tfootTagClose(); 879 } 880 break; 881 } 882 } 883 catch (RecognitionException re) { 884 _localctx.exception = re; 885 _errHandler.reportError(this, re); 886 _errHandler.recover(this, re); 887 } 888 finally { 889 exitRule(); 890 } 891 return _localctx; 892 } 893 894 public static class HtmlElementOpenContext extends ParserRuleContext { 895 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 896 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 897 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 898 public List<AttributeContext> attribute() { 899 return getRuleContexts(AttributeContext.class); 900 } 901 public AttributeContext attribute(int i) { 902 return getRuleContext(AttributeContext.class,i); 903 } 904 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 905 public TerminalNode NEWLINE(int i) { 906 return getToken(JavadocParser.NEWLINE, i); 907 } 908 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 909 public TerminalNode LEADING_ASTERISK(int i) { 910 return getToken(JavadocParser.LEADING_ASTERISK, i); 911 } 912 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 913 public TerminalNode WS(int i) { 914 return getToken(JavadocParser.WS, i); 915 } 916 public HtmlElementOpenContext(ParserRuleContext parent, int invokingState) { 917 super(parent, invokingState); 918 } 919 @Override public int getRuleIndex() { return RULE_htmlElementOpen; } 920 @Override 921 public void enterRule(ParseTreeListener listener) { 922 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementOpen(this); 923 } 924 @Override 925 public void exitRule(ParseTreeListener listener) { 926 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementOpen(this); 927 } 928 @Override 929 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 930 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementOpen(this); 931 else return visitor.visitChildren(this); 932 } 933 } 934 935 public final HtmlElementOpenContext htmlElementOpen() throws RecognitionException { 936 HtmlElementOpenContext _localctx = new HtmlElementOpenContext(_ctx, getState()); 937 enterRule(_localctx, 4, RULE_htmlElementOpen); 938 int _la; 939 try { 940 enterOuterAlt(_localctx, 1); 941 { 942 setState(229); 943 match(OPEN); 944 setState(230); 945 match(HTML_TAG_NAME); 946 setState(237); 947 _errHandler.sync(this); 948 _la = _input.LA(1); 949 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 950 { 951 setState(235); 952 switch (_input.LA(1)) { 953 case HTML_TAG_NAME: 954 { 955 setState(231); 956 attribute(); 957 } 958 break; 959 case NEWLINE: 960 { 961 setState(232); 962 match(NEWLINE); 963 } 964 break; 965 case LEADING_ASTERISK: 966 { 967 setState(233); 968 match(LEADING_ASTERISK); 969 } 970 break; 971 case WS: 972 { 973 setState(234); 974 match(WS); 975 } 976 break; 977 default: 978 throw new NoViableAltException(this); 979 } 980 } 981 setState(239); 982 _errHandler.sync(this); 983 _la = _input.LA(1); 984 } 985 setState(240); 986 match(CLOSE); 987 } 988 } 989 catch (RecognitionException re) { 990 _localctx.exception = re; 991 _errHandler.reportError(this, re); 992 _errHandler.recover(this, re); 993 } 994 finally { 995 exitRule(); 996 } 997 return _localctx; 998 } 999 1000 public static class HtmlElementCloseContext extends ParserRuleContext { 1001 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1002 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1003 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 1004 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1005 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1006 public TerminalNode NEWLINE(int i) { 1007 return getToken(JavadocParser.NEWLINE, i); 1008 } 1009 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1010 public TerminalNode LEADING_ASTERISK(int i) { 1011 return getToken(JavadocParser.LEADING_ASTERISK, i); 1012 } 1013 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1014 public TerminalNode WS(int i) { 1015 return getToken(JavadocParser.WS, i); 1016 } 1017 public HtmlElementCloseContext(ParserRuleContext parent, int invokingState) { 1018 super(parent, invokingState); 1019 } 1020 @Override public int getRuleIndex() { return RULE_htmlElementClose; } 1021 @Override 1022 public void enterRule(ParseTreeListener listener) { 1023 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementClose(this); 1024 } 1025 @Override 1026 public void exitRule(ParseTreeListener listener) { 1027 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementClose(this); 1028 } 1029 @Override 1030 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1031 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementClose(this); 1032 else return visitor.visitChildren(this); 1033 } 1034 } 1035 1036 public final HtmlElementCloseContext htmlElementClose() throws RecognitionException { 1037 HtmlElementCloseContext _localctx = new HtmlElementCloseContext(_ctx, getState()); 1038 enterRule(_localctx, 6, RULE_htmlElementClose); 1039 int _la; 1040 try { 1041 enterOuterAlt(_localctx, 1); 1042 { 1043 setState(242); 1044 match(OPEN); 1045 setState(243); 1046 match(SLASH); 1047 setState(244); 1048 match(HTML_TAG_NAME); 1049 setState(248); 1050 _errHandler.sync(this); 1051 _la = _input.LA(1); 1052 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1053 { 1054 { 1055 setState(245); 1056 _la = _input.LA(1); 1057 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1058 _errHandler.recoverInline(this); 1059 } else { 1060 consume(); 1061 } 1062 } 1063 } 1064 setState(250); 1065 _errHandler.sync(this); 1066 _la = _input.LA(1); 1067 } 1068 setState(251); 1069 match(CLOSE); 1070 } 1071 } 1072 catch (RecognitionException re) { 1073 _localctx.exception = re; 1074 _errHandler.reportError(this, re); 1075 _errHandler.recover(this, re); 1076 } 1077 finally { 1078 exitRule(); 1079 } 1080 return _localctx; 1081 } 1082 1083 public static class AttributeContext extends ParserRuleContext { 1084 public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); } 1085 public TerminalNode HTML_TAG_NAME(int i) { 1086 return getToken(JavadocParser.HTML_TAG_NAME, i); 1087 } 1088 public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); } 1089 public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); } 1090 public TextContext text() { 1091 return getRuleContext(TextContext.class,0); 1092 } 1093 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1094 public TerminalNode NEWLINE(int i) { 1095 return getToken(JavadocParser.NEWLINE, i); 1096 } 1097 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1098 public TerminalNode LEADING_ASTERISK(int i) { 1099 return getToken(JavadocParser.LEADING_ASTERISK, i); 1100 } 1101 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1102 public TerminalNode WS(int i) { 1103 return getToken(JavadocParser.WS, i); 1104 } 1105 public AttributeContext(ParserRuleContext parent, int invokingState) { 1106 super(parent, invokingState); 1107 } 1108 @Override public int getRuleIndex() { return RULE_attribute; } 1109 @Override 1110 public void enterRule(ParseTreeListener listener) { 1111 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAttribute(this); 1112 } 1113 @Override 1114 public void exitRule(ParseTreeListener listener) { 1115 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAttribute(this); 1116 } 1117 @Override 1118 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1119 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAttribute(this); 1120 else return visitor.visitChildren(this); 1121 } 1122 } 1123 1124 public final AttributeContext attribute() throws RecognitionException { 1125 AttributeContext _localctx = new AttributeContext(_ctx, getState()); 1126 enterRule(_localctx, 8, RULE_attribute); 1127 int _la; 1128 try { 1129 int _alt; 1130 enterOuterAlt(_localctx, 1); 1131 { 1132 setState(253); 1133 match(HTML_TAG_NAME); 1134 setState(257); 1135 _errHandler.sync(this); 1136 _la = _input.LA(1); 1137 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1138 { 1139 { 1140 setState(254); 1141 _la = _input.LA(1); 1142 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1143 _errHandler.recoverInline(this); 1144 } else { 1145 consume(); 1146 } 1147 } 1148 } 1149 setState(259); 1150 _errHandler.sync(this); 1151 _la = _input.LA(1); 1152 } 1153 setState(260); 1154 match(EQUALS); 1155 setState(264); 1156 _errHandler.sync(this); 1157 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1158 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1159 if ( _alt==1 ) { 1160 { 1161 { 1162 setState(261); 1163 _la = _input.LA(1); 1164 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1165 _errHandler.recoverInline(this); 1166 } else { 1167 consume(); 1168 } 1169 } 1170 } 1171 } 1172 setState(266); 1173 _errHandler.sync(this); 1174 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1175 } 1176 setState(270); 1177 switch (_input.LA(1)) { 1178 case ATTR_VALUE: 1179 { 1180 setState(267); 1181 match(ATTR_VALUE); 1182 } 1183 break; 1184 case WS: 1185 case CHAR: 1186 { 1187 setState(268); 1188 text(); 1189 } 1190 break; 1191 case HTML_TAG_NAME: 1192 { 1193 setState(269); 1194 match(HTML_TAG_NAME); 1195 } 1196 break; 1197 default: 1198 throw new NoViableAltException(this); 1199 } 1200 } 1201 } 1202 catch (RecognitionException re) { 1203 _localctx.exception = re; 1204 _errHandler.reportError(this, re); 1205 _errHandler.recover(this, re); 1206 } 1207 finally { 1208 exitRule(); 1209 } 1210 return _localctx; 1211 } 1212 1213 public static class HtmlTagContext extends ParserRuleContext { 1214 public HtmlElementOpenContext htmlElementOpen; 1215 public HtmlElementOpenContext htmlElementOpen() { 1216 return getRuleContext(HtmlElementOpenContext.class,0); 1217 } 1218 public HtmlElementCloseContext htmlElementClose() { 1219 return getRuleContext(HtmlElementCloseContext.class,0); 1220 } 1221 public List<HtmlElementContext> htmlElement() { 1222 return getRuleContexts(HtmlElementContext.class); 1223 } 1224 public HtmlElementContext htmlElement(int i) { 1225 return getRuleContext(HtmlElementContext.class,i); 1226 } 1227 public List<HtmlCommentContext> htmlComment() { 1228 return getRuleContexts(HtmlCommentContext.class); 1229 } 1230 public HtmlCommentContext htmlComment(int i) { 1231 return getRuleContext(HtmlCommentContext.class,i); 1232 } 1233 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1234 public TerminalNode CDATA(int i) { 1235 return getToken(JavadocParser.CDATA, i); 1236 } 1237 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1238 public TerminalNode NEWLINE(int i) { 1239 return getToken(JavadocParser.NEWLINE, i); 1240 } 1241 public List<TextContext> text() { 1242 return getRuleContexts(TextContext.class); 1243 } 1244 public TextContext text(int i) { 1245 return getRuleContext(TextContext.class,i); 1246 } 1247 public List<JavadocInlineTagContext> javadocInlineTag() { 1248 return getRuleContexts(JavadocInlineTagContext.class); 1249 } 1250 public JavadocInlineTagContext javadocInlineTag(int i) { 1251 return getRuleContext(JavadocInlineTagContext.class,i); 1252 } 1253 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1254 public TerminalNode LEADING_ASTERISK(int i) { 1255 return getToken(JavadocParser.LEADING_ASTERISK, i); 1256 } 1257 public HtmlTagContext(ParserRuleContext parent, int invokingState) { 1258 super(parent, invokingState); 1259 } 1260 @Override public int getRuleIndex() { return RULE_htmlTag; } 1261 @Override 1262 public void enterRule(ParseTreeListener listener) { 1263 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTag(this); 1264 } 1265 @Override 1266 public void exitRule(ParseTreeListener listener) { 1267 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTag(this); 1268 } 1269 @Override 1270 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1271 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTag(this); 1272 else return visitor.visitChildren(this); 1273 } 1274 } 1275 1276 public final HtmlTagContext htmlTag() throws RecognitionException { 1277 HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState()); 1278 enterRule(_localctx, 10, RULE_htmlTag); 1279 try { 1280 int _alt; 1281 setState(304); 1282 _errHandler.sync(this); 1283 switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { 1284 case 1: 1285 enterOuterAlt(_localctx, 1); 1286 { 1287 setState(272); 1288 htmlElementOpen(); 1289 setState(283); 1290 _errHandler.sync(this); 1291 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1292 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1293 if ( _alt==1 ) { 1294 { 1295 setState(281); 1296 _errHandler.sync(this); 1297 switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { 1298 case 1: 1299 { 1300 setState(273); 1301 htmlElement(); 1302 } 1303 break; 1304 case 2: 1305 { 1306 { 1307 setState(274); 1308 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1309 setState(275); 1310 match(LEADING_ASTERISK); 1311 } 1312 } 1313 break; 1314 case 3: 1315 { 1316 setState(276); 1317 htmlComment(); 1318 } 1319 break; 1320 case 4: 1321 { 1322 setState(277); 1323 match(CDATA); 1324 } 1325 break; 1326 case 5: 1327 { 1328 setState(278); 1329 match(NEWLINE); 1330 } 1331 break; 1332 case 6: 1333 { 1334 setState(279); 1335 text(); 1336 } 1337 break; 1338 case 7: 1339 { 1340 setState(280); 1341 javadocInlineTag(); 1342 } 1343 break; 1344 } 1345 } 1346 } 1347 setState(285); 1348 _errHandler.sync(this); 1349 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1350 } 1351 setState(286); 1352 htmlElementClose(); 1353 } 1354 break; 1355 case 2: 1356 enterOuterAlt(_localctx, 2); 1357 { 1358 setState(288); 1359 ((HtmlTagContext)_localctx).htmlElementOpen = htmlElementOpen(); 1360 setState(299); 1361 _errHandler.sync(this); 1362 _alt = getInterpreter().adaptivePredict(_input,15,_ctx); 1363 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1364 if ( _alt==1 ) { 1365 { 1366 setState(297); 1367 _errHandler.sync(this); 1368 switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { 1369 case 1: 1370 { 1371 setState(289); 1372 htmlElement(); 1373 } 1374 break; 1375 case 2: 1376 { 1377 { 1378 setState(290); 1379 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1380 setState(291); 1381 match(LEADING_ASTERISK); 1382 } 1383 } 1384 break; 1385 case 3: 1386 { 1387 setState(292); 1388 htmlComment(); 1389 } 1390 break; 1391 case 4: 1392 { 1393 setState(293); 1394 match(CDATA); 1395 } 1396 break; 1397 case 5: 1398 { 1399 setState(294); 1400 match(NEWLINE); 1401 } 1402 break; 1403 case 6: 1404 { 1405 setState(295); 1406 text(); 1407 } 1408 break; 1409 case 7: 1410 { 1411 setState(296); 1412 javadocInlineTag(); 1413 } 1414 break; 1415 } 1416 } 1417 } 1418 setState(301); 1419 _errHandler.sync(this); 1420 _alt = getInterpreter().adaptivePredict(_input,15,_ctx); 1421 } 1422 notifyErrorListeners(((HtmlTagContext)_localctx).htmlElementOpen.getToken(HTML_TAG_NAME, 0).getSymbol(), "javadoc.missed.html.close", null); 1423 } 1424 break; 1425 } 1426 } 1427 catch (RecognitionException re) { 1428 _localctx.exception = re; 1429 _errHandler.reportError(this, re); 1430 _errHandler.recover(this, re); 1431 } 1432 finally { 1433 exitRule(); 1434 } 1435 return _localctx; 1436 } 1437 1438 public static class PTagOpenContext extends ParserRuleContext { 1439 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1440 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1441 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1442 public List<AttributeContext> attribute() { 1443 return getRuleContexts(AttributeContext.class); 1444 } 1445 public AttributeContext attribute(int i) { 1446 return getRuleContext(AttributeContext.class,i); 1447 } 1448 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1449 public TerminalNode NEWLINE(int i) { 1450 return getToken(JavadocParser.NEWLINE, i); 1451 } 1452 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1453 public TerminalNode LEADING_ASTERISK(int i) { 1454 return getToken(JavadocParser.LEADING_ASTERISK, i); 1455 } 1456 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1457 public TerminalNode WS(int i) { 1458 return getToken(JavadocParser.WS, i); 1459 } 1460 public PTagOpenContext(ParserRuleContext parent, int invokingState) { 1461 super(parent, invokingState); 1462 } 1463 @Override public int getRuleIndex() { return RULE_pTagOpen; } 1464 @Override 1465 public void enterRule(ParseTreeListener listener) { 1466 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagOpen(this); 1467 } 1468 @Override 1469 public void exitRule(ParseTreeListener listener) { 1470 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagOpen(this); 1471 } 1472 @Override 1473 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1474 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagOpen(this); 1475 else return visitor.visitChildren(this); 1476 } 1477 } 1478 1479 public final PTagOpenContext pTagOpen() throws RecognitionException { 1480 PTagOpenContext _localctx = new PTagOpenContext(_ctx, getState()); 1481 enterRule(_localctx, 12, RULE_pTagOpen); 1482 int _la; 1483 try { 1484 enterOuterAlt(_localctx, 1); 1485 { 1486 setState(306); 1487 match(OPEN); 1488 setState(307); 1489 match(P_HTML_TAG_NAME); 1490 setState(314); 1491 _errHandler.sync(this); 1492 _la = _input.LA(1); 1493 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 1494 { 1495 setState(312); 1496 switch (_input.LA(1)) { 1497 case HTML_TAG_NAME: 1498 { 1499 setState(308); 1500 attribute(); 1501 } 1502 break; 1503 case NEWLINE: 1504 { 1505 setState(309); 1506 match(NEWLINE); 1507 } 1508 break; 1509 case LEADING_ASTERISK: 1510 { 1511 setState(310); 1512 match(LEADING_ASTERISK); 1513 } 1514 break; 1515 case WS: 1516 { 1517 setState(311); 1518 match(WS); 1519 } 1520 break; 1521 default: 1522 throw new NoViableAltException(this); 1523 } 1524 } 1525 setState(316); 1526 _errHandler.sync(this); 1527 _la = _input.LA(1); 1528 } 1529 setState(317); 1530 match(CLOSE); 1531 } 1532 } 1533 catch (RecognitionException re) { 1534 _localctx.exception = re; 1535 _errHandler.reportError(this, re); 1536 _errHandler.recover(this, re); 1537 } 1538 finally { 1539 exitRule(); 1540 } 1541 return _localctx; 1542 } 1543 1544 public static class PTagCloseContext extends ParserRuleContext { 1545 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1546 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1547 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1548 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1549 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1550 public TerminalNode NEWLINE(int i) { 1551 return getToken(JavadocParser.NEWLINE, i); 1552 } 1553 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1554 public TerminalNode LEADING_ASTERISK(int i) { 1555 return getToken(JavadocParser.LEADING_ASTERISK, i); 1556 } 1557 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1558 public TerminalNode WS(int i) { 1559 return getToken(JavadocParser.WS, i); 1560 } 1561 public PTagCloseContext(ParserRuleContext parent, int invokingState) { 1562 super(parent, invokingState); 1563 } 1564 @Override public int getRuleIndex() { return RULE_pTagClose; } 1565 @Override 1566 public void enterRule(ParseTreeListener listener) { 1567 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagClose(this); 1568 } 1569 @Override 1570 public void exitRule(ParseTreeListener listener) { 1571 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagClose(this); 1572 } 1573 @Override 1574 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1575 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagClose(this); 1576 else return visitor.visitChildren(this); 1577 } 1578 } 1579 1580 public final PTagCloseContext pTagClose() throws RecognitionException { 1581 PTagCloseContext _localctx = new PTagCloseContext(_ctx, getState()); 1582 enterRule(_localctx, 14, RULE_pTagClose); 1583 int _la; 1584 try { 1585 enterOuterAlt(_localctx, 1); 1586 { 1587 setState(319); 1588 match(OPEN); 1589 setState(320); 1590 match(SLASH); 1591 setState(321); 1592 match(P_HTML_TAG_NAME); 1593 setState(325); 1594 _errHandler.sync(this); 1595 _la = _input.LA(1); 1596 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1597 { 1598 { 1599 setState(322); 1600 _la = _input.LA(1); 1601 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1602 _errHandler.recoverInline(this); 1603 } else { 1604 consume(); 1605 } 1606 } 1607 } 1608 setState(327); 1609 _errHandler.sync(this); 1610 _la = _input.LA(1); 1611 } 1612 setState(328); 1613 match(CLOSE); 1614 } 1615 } 1616 catch (RecognitionException re) { 1617 _localctx.exception = re; 1618 _errHandler.reportError(this, re); 1619 _errHandler.recover(this, re); 1620 } 1621 finally { 1622 exitRule(); 1623 } 1624 return _localctx; 1625 } 1626 1627 public static class ParagraphContext extends ParserRuleContext { 1628 public PTagOpenContext pTagOpen() { 1629 return getRuleContext(PTagOpenContext.class,0); 1630 } 1631 public PTagCloseContext pTagClose() { 1632 return getRuleContext(PTagCloseContext.class,0); 1633 } 1634 public List<HtmlTagContext> htmlTag() { 1635 return getRuleContexts(HtmlTagContext.class); 1636 } 1637 public HtmlTagContext htmlTag(int i) { 1638 return getRuleContext(HtmlTagContext.class,i); 1639 } 1640 public List<SingletonTagContext> singletonTag() { 1641 return getRuleContexts(SingletonTagContext.class); 1642 } 1643 public SingletonTagContext singletonTag(int i) { 1644 return getRuleContext(SingletonTagContext.class,i); 1645 } 1646 public List<LiContext> li() { 1647 return getRuleContexts(LiContext.class); 1648 } 1649 public LiContext li(int i) { 1650 return getRuleContext(LiContext.class,i); 1651 } 1652 public List<TrContext> tr() { 1653 return getRuleContexts(TrContext.class); 1654 } 1655 public TrContext tr(int i) { 1656 return getRuleContext(TrContext.class,i); 1657 } 1658 public List<TdContext> td() { 1659 return getRuleContexts(TdContext.class); 1660 } 1661 public TdContext td(int i) { 1662 return getRuleContext(TdContext.class,i); 1663 } 1664 public List<ThContext> th() { 1665 return getRuleContexts(ThContext.class); 1666 } 1667 public ThContext th(int i) { 1668 return getRuleContext(ThContext.class,i); 1669 } 1670 public List<BodyContext> body() { 1671 return getRuleContexts(BodyContext.class); 1672 } 1673 public BodyContext body(int i) { 1674 return getRuleContext(BodyContext.class,i); 1675 } 1676 public List<ColgroupContext> colgroup() { 1677 return getRuleContexts(ColgroupContext.class); 1678 } 1679 public ColgroupContext colgroup(int i) { 1680 return getRuleContext(ColgroupContext.class,i); 1681 } 1682 public List<DdContext> dd() { 1683 return getRuleContexts(DdContext.class); 1684 } 1685 public DdContext dd(int i) { 1686 return getRuleContext(DdContext.class,i); 1687 } 1688 public List<DtContext> dt() { 1689 return getRuleContexts(DtContext.class); 1690 } 1691 public DtContext dt(int i) { 1692 return getRuleContext(DtContext.class,i); 1693 } 1694 public List<HeadContext> head() { 1695 return getRuleContexts(HeadContext.class); 1696 } 1697 public HeadContext head(int i) { 1698 return getRuleContext(HeadContext.class,i); 1699 } 1700 public List<HtmlContext> html() { 1701 return getRuleContexts(HtmlContext.class); 1702 } 1703 public HtmlContext html(int i) { 1704 return getRuleContext(HtmlContext.class,i); 1705 } 1706 public List<OptionContext> option() { 1707 return getRuleContexts(OptionContext.class); 1708 } 1709 public OptionContext option(int i) { 1710 return getRuleContext(OptionContext.class,i); 1711 } 1712 public List<TbodyContext> tbody() { 1713 return getRuleContexts(TbodyContext.class); 1714 } 1715 public TbodyContext tbody(int i) { 1716 return getRuleContext(TbodyContext.class,i); 1717 } 1718 public List<TheadContext> thead() { 1719 return getRuleContexts(TheadContext.class); 1720 } 1721 public TheadContext thead(int i) { 1722 return getRuleContext(TheadContext.class,i); 1723 } 1724 public List<TfootContext> tfoot() { 1725 return getRuleContexts(TfootContext.class); 1726 } 1727 public TfootContext tfoot(int i) { 1728 return getRuleContext(TfootContext.class,i); 1729 } 1730 public List<LiTagOpenContext> liTagOpen() { 1731 return getRuleContexts(LiTagOpenContext.class); 1732 } 1733 public LiTagOpenContext liTagOpen(int i) { 1734 return getRuleContext(LiTagOpenContext.class,i); 1735 } 1736 public List<TrTagOpenContext> trTagOpen() { 1737 return getRuleContexts(TrTagOpenContext.class); 1738 } 1739 public TrTagOpenContext trTagOpen(int i) { 1740 return getRuleContext(TrTagOpenContext.class,i); 1741 } 1742 public List<TdTagOpenContext> tdTagOpen() { 1743 return getRuleContexts(TdTagOpenContext.class); 1744 } 1745 public TdTagOpenContext tdTagOpen(int i) { 1746 return getRuleContext(TdTagOpenContext.class,i); 1747 } 1748 public List<ThTagOpenContext> thTagOpen() { 1749 return getRuleContexts(ThTagOpenContext.class); 1750 } 1751 public ThTagOpenContext thTagOpen(int i) { 1752 return getRuleContext(ThTagOpenContext.class,i); 1753 } 1754 public List<BodyTagOpenContext> bodyTagOpen() { 1755 return getRuleContexts(BodyTagOpenContext.class); 1756 } 1757 public BodyTagOpenContext bodyTagOpen(int i) { 1758 return getRuleContext(BodyTagOpenContext.class,i); 1759 } 1760 public List<ColgroupTagOpenContext> colgroupTagOpen() { 1761 return getRuleContexts(ColgroupTagOpenContext.class); 1762 } 1763 public ColgroupTagOpenContext colgroupTagOpen(int i) { 1764 return getRuleContext(ColgroupTagOpenContext.class,i); 1765 } 1766 public List<DdTagOpenContext> ddTagOpen() { 1767 return getRuleContexts(DdTagOpenContext.class); 1768 } 1769 public DdTagOpenContext ddTagOpen(int i) { 1770 return getRuleContext(DdTagOpenContext.class,i); 1771 } 1772 public List<DtTagOpenContext> dtTagOpen() { 1773 return getRuleContexts(DtTagOpenContext.class); 1774 } 1775 public DtTagOpenContext dtTagOpen(int i) { 1776 return getRuleContext(DtTagOpenContext.class,i); 1777 } 1778 public List<HeadTagOpenContext> headTagOpen() { 1779 return getRuleContexts(HeadTagOpenContext.class); 1780 } 1781 public HeadTagOpenContext headTagOpen(int i) { 1782 return getRuleContext(HeadTagOpenContext.class,i); 1783 } 1784 public List<HtmlTagOpenContext> htmlTagOpen() { 1785 return getRuleContexts(HtmlTagOpenContext.class); 1786 } 1787 public HtmlTagOpenContext htmlTagOpen(int i) { 1788 return getRuleContext(HtmlTagOpenContext.class,i); 1789 } 1790 public List<OptionTagOpenContext> optionTagOpen() { 1791 return getRuleContexts(OptionTagOpenContext.class); 1792 } 1793 public OptionTagOpenContext optionTagOpen(int i) { 1794 return getRuleContext(OptionTagOpenContext.class,i); 1795 } 1796 public List<TbodyTagOpenContext> tbodyTagOpen() { 1797 return getRuleContexts(TbodyTagOpenContext.class); 1798 } 1799 public TbodyTagOpenContext tbodyTagOpen(int i) { 1800 return getRuleContext(TbodyTagOpenContext.class,i); 1801 } 1802 public List<TheadTagOpenContext> theadTagOpen() { 1803 return getRuleContexts(TheadTagOpenContext.class); 1804 } 1805 public TheadTagOpenContext theadTagOpen(int i) { 1806 return getRuleContext(TheadTagOpenContext.class,i); 1807 } 1808 public List<TfootTagOpenContext> tfootTagOpen() { 1809 return getRuleContexts(TfootTagOpenContext.class); 1810 } 1811 public TfootTagOpenContext tfootTagOpen(int i) { 1812 return getRuleContext(TfootTagOpenContext.class,i); 1813 } 1814 public List<HtmlCommentContext> htmlComment() { 1815 return getRuleContexts(HtmlCommentContext.class); 1816 } 1817 public HtmlCommentContext htmlComment(int i) { 1818 return getRuleContext(HtmlCommentContext.class,i); 1819 } 1820 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1821 public TerminalNode CDATA(int i) { 1822 return getToken(JavadocParser.CDATA, i); 1823 } 1824 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1825 public TerminalNode NEWLINE(int i) { 1826 return getToken(JavadocParser.NEWLINE, i); 1827 } 1828 public List<TextContext> text() { 1829 return getRuleContexts(TextContext.class); 1830 } 1831 public TextContext text(int i) { 1832 return getRuleContext(TextContext.class,i); 1833 } 1834 public List<JavadocInlineTagContext> javadocInlineTag() { 1835 return getRuleContexts(JavadocInlineTagContext.class); 1836 } 1837 public JavadocInlineTagContext javadocInlineTag(int i) { 1838 return getRuleContext(JavadocInlineTagContext.class,i); 1839 } 1840 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1841 public TerminalNode LEADING_ASTERISK(int i) { 1842 return getToken(JavadocParser.LEADING_ASTERISK, i); 1843 } 1844 public ParagraphContext(ParserRuleContext parent, int invokingState) { 1845 super(parent, invokingState); 1846 } 1847 @Override public int getRuleIndex() { return RULE_paragraph; } 1848 @Override 1849 public void enterRule(ParseTreeListener listener) { 1850 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParagraph(this); 1851 } 1852 @Override 1853 public void exitRule(ParseTreeListener listener) { 1854 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParagraph(this); 1855 } 1856 @Override 1857 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1858 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParagraph(this); 1859 else return visitor.visitChildren(this); 1860 } 1861 } 1862 1863 public final ParagraphContext paragraph() throws RecognitionException { 1864 ParagraphContext _localctx = new ParagraphContext(_ctx, getState()); 1865 enterRule(_localctx, 16, RULE_paragraph); 1866 try { 1867 int _alt; 1868 enterOuterAlt(_localctx, 1); 1869 { 1870 setState(330); 1871 pTagOpen(); 1872 setState(370); 1873 _errHandler.sync(this); 1874 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 1875 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1876 if ( _alt==1 ) { 1877 { 1878 setState(368); 1879 _errHandler.sync(this); 1880 switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) { 1881 case 1: 1882 { 1883 setState(331); 1884 htmlTag(); 1885 } 1886 break; 1887 case 2: 1888 { 1889 setState(332); 1890 singletonTag(); 1891 } 1892 break; 1893 case 3: 1894 { 1895 setState(333); 1896 li(); 1897 } 1898 break; 1899 case 4: 1900 { 1901 setState(334); 1902 tr(); 1903 } 1904 break; 1905 case 5: 1906 { 1907 setState(335); 1908 td(); 1909 } 1910 break; 1911 case 6: 1912 { 1913 setState(336); 1914 th(); 1915 } 1916 break; 1917 case 7: 1918 { 1919 setState(337); 1920 body(); 1921 } 1922 break; 1923 case 8: 1924 { 1925 setState(338); 1926 colgroup(); 1927 } 1928 break; 1929 case 9: 1930 { 1931 setState(339); 1932 dd(); 1933 } 1934 break; 1935 case 10: 1936 { 1937 setState(340); 1938 dt(); 1939 } 1940 break; 1941 case 11: 1942 { 1943 setState(341); 1944 head(); 1945 } 1946 break; 1947 case 12: 1948 { 1949 setState(342); 1950 html(); 1951 } 1952 break; 1953 case 13: 1954 { 1955 setState(343); 1956 option(); 1957 } 1958 break; 1959 case 14: 1960 { 1961 setState(344); 1962 tbody(); 1963 } 1964 break; 1965 case 15: 1966 { 1967 setState(345); 1968 thead(); 1969 } 1970 break; 1971 case 16: 1972 { 1973 setState(346); 1974 tfoot(); 1975 } 1976 break; 1977 case 17: 1978 { 1979 setState(347); 1980 liTagOpen(); 1981 } 1982 break; 1983 case 18: 1984 { 1985 setState(348); 1986 trTagOpen(); 1987 } 1988 break; 1989 case 19: 1990 { 1991 setState(349); 1992 tdTagOpen(); 1993 } 1994 break; 1995 case 20: 1996 { 1997 setState(350); 1998 thTagOpen(); 1999 } 2000 break; 2001 case 21: 2002 { 2003 setState(351); 2004 bodyTagOpen(); 2005 } 2006 break; 2007 case 22: 2008 { 2009 setState(352); 2010 colgroupTagOpen(); 2011 } 2012 break; 2013 case 23: 2014 { 2015 setState(353); 2016 ddTagOpen(); 2017 } 2018 break; 2019 case 24: 2020 { 2021 setState(354); 2022 dtTagOpen(); 2023 } 2024 break; 2025 case 25: 2026 { 2027 setState(355); 2028 headTagOpen(); 2029 } 2030 break; 2031 case 26: 2032 { 2033 setState(356); 2034 htmlTagOpen(); 2035 } 2036 break; 2037 case 27: 2038 { 2039 setState(357); 2040 optionTagOpen(); 2041 } 2042 break; 2043 case 28: 2044 { 2045 setState(358); 2046 tbodyTagOpen(); 2047 } 2048 break; 2049 case 29: 2050 { 2051 setState(359); 2052 theadTagOpen(); 2053 } 2054 break; 2055 case 30: 2056 { 2057 setState(360); 2058 tfootTagOpen(); 2059 } 2060 break; 2061 case 31: 2062 { 2063 { 2064 setState(361); 2065 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2066 setState(362); 2067 match(LEADING_ASTERISK); 2068 } 2069 } 2070 break; 2071 case 32: 2072 { 2073 setState(363); 2074 htmlComment(); 2075 } 2076 break; 2077 case 33: 2078 { 2079 setState(364); 2080 match(CDATA); 2081 } 2082 break; 2083 case 34: 2084 { 2085 setState(365); 2086 match(NEWLINE); 2087 } 2088 break; 2089 case 35: 2090 { 2091 setState(366); 2092 text(); 2093 } 2094 break; 2095 case 36: 2096 { 2097 setState(367); 2098 javadocInlineTag(); 2099 } 2100 break; 2101 } 2102 } 2103 } 2104 setState(372); 2105 _errHandler.sync(this); 2106 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 2107 } 2108 setState(373); 2109 pTagClose(); 2110 } 2111 } 2112 catch (RecognitionException re) { 2113 _localctx.exception = re; 2114 _errHandler.reportError(this, re); 2115 _errHandler.recover(this, re); 2116 } 2117 finally { 2118 exitRule(); 2119 } 2120 return _localctx; 2121 } 2122 2123 public static class LiTagOpenContext extends ParserRuleContext { 2124 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2125 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2126 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2127 public List<AttributeContext> attribute() { 2128 return getRuleContexts(AttributeContext.class); 2129 } 2130 public AttributeContext attribute(int i) { 2131 return getRuleContext(AttributeContext.class,i); 2132 } 2133 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2134 public TerminalNode NEWLINE(int i) { 2135 return getToken(JavadocParser.NEWLINE, i); 2136 } 2137 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2138 public TerminalNode LEADING_ASTERISK(int i) { 2139 return getToken(JavadocParser.LEADING_ASTERISK, i); 2140 } 2141 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2142 public TerminalNode WS(int i) { 2143 return getToken(JavadocParser.WS, i); 2144 } 2145 public LiTagOpenContext(ParserRuleContext parent, int invokingState) { 2146 super(parent, invokingState); 2147 } 2148 @Override public int getRuleIndex() { return RULE_liTagOpen; } 2149 @Override 2150 public void enterRule(ParseTreeListener listener) { 2151 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagOpen(this); 2152 } 2153 @Override 2154 public void exitRule(ParseTreeListener listener) { 2155 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagOpen(this); 2156 } 2157 @Override 2158 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2159 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagOpen(this); 2160 else return visitor.visitChildren(this); 2161 } 2162 } 2163 2164 public final LiTagOpenContext liTagOpen() throws RecognitionException { 2165 LiTagOpenContext _localctx = new LiTagOpenContext(_ctx, getState()); 2166 enterRule(_localctx, 18, RULE_liTagOpen); 2167 int _la; 2168 try { 2169 enterOuterAlt(_localctx, 1); 2170 { 2171 setState(375); 2172 match(OPEN); 2173 setState(376); 2174 match(LI_HTML_TAG_NAME); 2175 setState(383); 2176 _errHandler.sync(this); 2177 _la = _input.LA(1); 2178 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2179 { 2180 setState(381); 2181 switch (_input.LA(1)) { 2182 case HTML_TAG_NAME: 2183 { 2184 setState(377); 2185 attribute(); 2186 } 2187 break; 2188 case NEWLINE: 2189 { 2190 setState(378); 2191 match(NEWLINE); 2192 } 2193 break; 2194 case LEADING_ASTERISK: 2195 { 2196 setState(379); 2197 match(LEADING_ASTERISK); 2198 } 2199 break; 2200 case WS: 2201 { 2202 setState(380); 2203 match(WS); 2204 } 2205 break; 2206 default: 2207 throw new NoViableAltException(this); 2208 } 2209 } 2210 setState(385); 2211 _errHandler.sync(this); 2212 _la = _input.LA(1); 2213 } 2214 setState(386); 2215 match(CLOSE); 2216 } 2217 } 2218 catch (RecognitionException re) { 2219 _localctx.exception = re; 2220 _errHandler.reportError(this, re); 2221 _errHandler.recover(this, re); 2222 } 2223 finally { 2224 exitRule(); 2225 } 2226 return _localctx; 2227 } 2228 2229 public static class LiTagCloseContext extends ParserRuleContext { 2230 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2231 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2232 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2233 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2234 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2235 public TerminalNode NEWLINE(int i) { 2236 return getToken(JavadocParser.NEWLINE, i); 2237 } 2238 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2239 public TerminalNode LEADING_ASTERISK(int i) { 2240 return getToken(JavadocParser.LEADING_ASTERISK, i); 2241 } 2242 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2243 public TerminalNode WS(int i) { 2244 return getToken(JavadocParser.WS, i); 2245 } 2246 public LiTagCloseContext(ParserRuleContext parent, int invokingState) { 2247 super(parent, invokingState); 2248 } 2249 @Override public int getRuleIndex() { return RULE_liTagClose; } 2250 @Override 2251 public void enterRule(ParseTreeListener listener) { 2252 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagClose(this); 2253 } 2254 @Override 2255 public void exitRule(ParseTreeListener listener) { 2256 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagClose(this); 2257 } 2258 @Override 2259 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2260 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagClose(this); 2261 else return visitor.visitChildren(this); 2262 } 2263 } 2264 2265 public final LiTagCloseContext liTagClose() throws RecognitionException { 2266 LiTagCloseContext _localctx = new LiTagCloseContext(_ctx, getState()); 2267 enterRule(_localctx, 20, RULE_liTagClose); 2268 int _la; 2269 try { 2270 enterOuterAlt(_localctx, 1); 2271 { 2272 setState(388); 2273 match(OPEN); 2274 setState(389); 2275 match(SLASH); 2276 setState(390); 2277 match(LI_HTML_TAG_NAME); 2278 setState(394); 2279 _errHandler.sync(this); 2280 _la = _input.LA(1); 2281 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2282 { 2283 { 2284 setState(391); 2285 _la = _input.LA(1); 2286 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2287 _errHandler.recoverInline(this); 2288 } else { 2289 consume(); 2290 } 2291 } 2292 } 2293 setState(396); 2294 _errHandler.sync(this); 2295 _la = _input.LA(1); 2296 } 2297 setState(397); 2298 match(CLOSE); 2299 } 2300 } 2301 catch (RecognitionException re) { 2302 _localctx.exception = re; 2303 _errHandler.reportError(this, re); 2304 _errHandler.recover(this, re); 2305 } 2306 finally { 2307 exitRule(); 2308 } 2309 return _localctx; 2310 } 2311 2312 public static class LiContext extends ParserRuleContext { 2313 public LiTagOpenContext liTagOpen() { 2314 return getRuleContext(LiTagOpenContext.class,0); 2315 } 2316 public LiTagCloseContext liTagClose() { 2317 return getRuleContext(LiTagCloseContext.class,0); 2318 } 2319 public List<HtmlTagContext> htmlTag() { 2320 return getRuleContexts(HtmlTagContext.class); 2321 } 2322 public HtmlTagContext htmlTag(int i) { 2323 return getRuleContext(HtmlTagContext.class,i); 2324 } 2325 public List<SingletonTagContext> singletonTag() { 2326 return getRuleContexts(SingletonTagContext.class); 2327 } 2328 public SingletonTagContext singletonTag(int i) { 2329 return getRuleContext(SingletonTagContext.class,i); 2330 } 2331 public List<ParagraphContext> paragraph() { 2332 return getRuleContexts(ParagraphContext.class); 2333 } 2334 public ParagraphContext paragraph(int i) { 2335 return getRuleContext(ParagraphContext.class,i); 2336 } 2337 public List<TrContext> tr() { 2338 return getRuleContexts(TrContext.class); 2339 } 2340 public TrContext tr(int i) { 2341 return getRuleContext(TrContext.class,i); 2342 } 2343 public List<TdContext> td() { 2344 return getRuleContexts(TdContext.class); 2345 } 2346 public TdContext td(int i) { 2347 return getRuleContext(TdContext.class,i); 2348 } 2349 public List<ThContext> th() { 2350 return getRuleContexts(ThContext.class); 2351 } 2352 public ThContext th(int i) { 2353 return getRuleContext(ThContext.class,i); 2354 } 2355 public List<BodyContext> body() { 2356 return getRuleContexts(BodyContext.class); 2357 } 2358 public BodyContext body(int i) { 2359 return getRuleContext(BodyContext.class,i); 2360 } 2361 public List<ColgroupContext> colgroup() { 2362 return getRuleContexts(ColgroupContext.class); 2363 } 2364 public ColgroupContext colgroup(int i) { 2365 return getRuleContext(ColgroupContext.class,i); 2366 } 2367 public List<DdContext> dd() { 2368 return getRuleContexts(DdContext.class); 2369 } 2370 public DdContext dd(int i) { 2371 return getRuleContext(DdContext.class,i); 2372 } 2373 public List<DtContext> dt() { 2374 return getRuleContexts(DtContext.class); 2375 } 2376 public DtContext dt(int i) { 2377 return getRuleContext(DtContext.class,i); 2378 } 2379 public List<HeadContext> head() { 2380 return getRuleContexts(HeadContext.class); 2381 } 2382 public HeadContext head(int i) { 2383 return getRuleContext(HeadContext.class,i); 2384 } 2385 public List<HtmlContext> html() { 2386 return getRuleContexts(HtmlContext.class); 2387 } 2388 public HtmlContext html(int i) { 2389 return getRuleContext(HtmlContext.class,i); 2390 } 2391 public List<OptionContext> option() { 2392 return getRuleContexts(OptionContext.class); 2393 } 2394 public OptionContext option(int i) { 2395 return getRuleContext(OptionContext.class,i); 2396 } 2397 public List<TbodyContext> tbody() { 2398 return getRuleContexts(TbodyContext.class); 2399 } 2400 public TbodyContext tbody(int i) { 2401 return getRuleContext(TbodyContext.class,i); 2402 } 2403 public List<TheadContext> thead() { 2404 return getRuleContexts(TheadContext.class); 2405 } 2406 public TheadContext thead(int i) { 2407 return getRuleContext(TheadContext.class,i); 2408 } 2409 public List<TfootContext> tfoot() { 2410 return getRuleContexts(TfootContext.class); 2411 } 2412 public TfootContext tfoot(int i) { 2413 return getRuleContext(TfootContext.class,i); 2414 } 2415 public List<PTagOpenContext> pTagOpen() { 2416 return getRuleContexts(PTagOpenContext.class); 2417 } 2418 public PTagOpenContext pTagOpen(int i) { 2419 return getRuleContext(PTagOpenContext.class,i); 2420 } 2421 public List<TrTagOpenContext> trTagOpen() { 2422 return getRuleContexts(TrTagOpenContext.class); 2423 } 2424 public TrTagOpenContext trTagOpen(int i) { 2425 return getRuleContext(TrTagOpenContext.class,i); 2426 } 2427 public List<TdTagOpenContext> tdTagOpen() { 2428 return getRuleContexts(TdTagOpenContext.class); 2429 } 2430 public TdTagOpenContext tdTagOpen(int i) { 2431 return getRuleContext(TdTagOpenContext.class,i); 2432 } 2433 public List<ThTagOpenContext> thTagOpen() { 2434 return getRuleContexts(ThTagOpenContext.class); 2435 } 2436 public ThTagOpenContext thTagOpen(int i) { 2437 return getRuleContext(ThTagOpenContext.class,i); 2438 } 2439 public List<BodyTagOpenContext> bodyTagOpen() { 2440 return getRuleContexts(BodyTagOpenContext.class); 2441 } 2442 public BodyTagOpenContext bodyTagOpen(int i) { 2443 return getRuleContext(BodyTagOpenContext.class,i); 2444 } 2445 public List<ColgroupTagOpenContext> colgroupTagOpen() { 2446 return getRuleContexts(ColgroupTagOpenContext.class); 2447 } 2448 public ColgroupTagOpenContext colgroupTagOpen(int i) { 2449 return getRuleContext(ColgroupTagOpenContext.class,i); 2450 } 2451 public List<DdTagOpenContext> ddTagOpen() { 2452 return getRuleContexts(DdTagOpenContext.class); 2453 } 2454 public DdTagOpenContext ddTagOpen(int i) { 2455 return getRuleContext(DdTagOpenContext.class,i); 2456 } 2457 public List<DtTagOpenContext> dtTagOpen() { 2458 return getRuleContexts(DtTagOpenContext.class); 2459 } 2460 public DtTagOpenContext dtTagOpen(int i) { 2461 return getRuleContext(DtTagOpenContext.class,i); 2462 } 2463 public List<HeadTagOpenContext> headTagOpen() { 2464 return getRuleContexts(HeadTagOpenContext.class); 2465 } 2466 public HeadTagOpenContext headTagOpen(int i) { 2467 return getRuleContext(HeadTagOpenContext.class,i); 2468 } 2469 public List<HtmlTagOpenContext> htmlTagOpen() { 2470 return getRuleContexts(HtmlTagOpenContext.class); 2471 } 2472 public HtmlTagOpenContext htmlTagOpen(int i) { 2473 return getRuleContext(HtmlTagOpenContext.class,i); 2474 } 2475 public List<OptionTagOpenContext> optionTagOpen() { 2476 return getRuleContexts(OptionTagOpenContext.class); 2477 } 2478 public OptionTagOpenContext optionTagOpen(int i) { 2479 return getRuleContext(OptionTagOpenContext.class,i); 2480 } 2481 public List<TbodyTagOpenContext> tbodyTagOpen() { 2482 return getRuleContexts(TbodyTagOpenContext.class); 2483 } 2484 public TbodyTagOpenContext tbodyTagOpen(int i) { 2485 return getRuleContext(TbodyTagOpenContext.class,i); 2486 } 2487 public List<TheadTagOpenContext> theadTagOpen() { 2488 return getRuleContexts(TheadTagOpenContext.class); 2489 } 2490 public TheadTagOpenContext theadTagOpen(int i) { 2491 return getRuleContext(TheadTagOpenContext.class,i); 2492 } 2493 public List<TfootTagOpenContext> tfootTagOpen() { 2494 return getRuleContexts(TfootTagOpenContext.class); 2495 } 2496 public TfootTagOpenContext tfootTagOpen(int i) { 2497 return getRuleContext(TfootTagOpenContext.class,i); 2498 } 2499 public List<HtmlCommentContext> htmlComment() { 2500 return getRuleContexts(HtmlCommentContext.class); 2501 } 2502 public HtmlCommentContext htmlComment(int i) { 2503 return getRuleContext(HtmlCommentContext.class,i); 2504 } 2505 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 2506 public TerminalNode CDATA(int i) { 2507 return getToken(JavadocParser.CDATA, i); 2508 } 2509 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2510 public TerminalNode NEWLINE(int i) { 2511 return getToken(JavadocParser.NEWLINE, i); 2512 } 2513 public List<TextContext> text() { 2514 return getRuleContexts(TextContext.class); 2515 } 2516 public TextContext text(int i) { 2517 return getRuleContext(TextContext.class,i); 2518 } 2519 public List<JavadocInlineTagContext> javadocInlineTag() { 2520 return getRuleContexts(JavadocInlineTagContext.class); 2521 } 2522 public JavadocInlineTagContext javadocInlineTag(int i) { 2523 return getRuleContext(JavadocInlineTagContext.class,i); 2524 } 2525 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2526 public TerminalNode LEADING_ASTERISK(int i) { 2527 return getToken(JavadocParser.LEADING_ASTERISK, i); 2528 } 2529 public LiContext(ParserRuleContext parent, int invokingState) { 2530 super(parent, invokingState); 2531 } 2532 @Override public int getRuleIndex() { return RULE_li; } 2533 @Override 2534 public void enterRule(ParseTreeListener listener) { 2535 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLi(this); 2536 } 2537 @Override 2538 public void exitRule(ParseTreeListener listener) { 2539 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLi(this); 2540 } 2541 @Override 2542 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2543 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLi(this); 2544 else return visitor.visitChildren(this); 2545 } 2546 } 2547 2548 public final LiContext li() throws RecognitionException { 2549 LiContext _localctx = new LiContext(_ctx, getState()); 2550 enterRule(_localctx, 22, RULE_li); 2551 try { 2552 int _alt; 2553 enterOuterAlt(_localctx, 1); 2554 { 2555 setState(399); 2556 liTagOpen(); 2557 setState(439); 2558 _errHandler.sync(this); 2559 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 2560 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 2561 if ( _alt==1 ) { 2562 { 2563 setState(437); 2564 _errHandler.sync(this); 2565 switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) { 2566 case 1: 2567 { 2568 setState(400); 2569 htmlTag(); 2570 } 2571 break; 2572 case 2: 2573 { 2574 setState(401); 2575 singletonTag(); 2576 } 2577 break; 2578 case 3: 2579 { 2580 setState(402); 2581 paragraph(); 2582 } 2583 break; 2584 case 4: 2585 { 2586 setState(403); 2587 tr(); 2588 } 2589 break; 2590 case 5: 2591 { 2592 setState(404); 2593 td(); 2594 } 2595 break; 2596 case 6: 2597 { 2598 setState(405); 2599 th(); 2600 } 2601 break; 2602 case 7: 2603 { 2604 setState(406); 2605 body(); 2606 } 2607 break; 2608 case 8: 2609 { 2610 setState(407); 2611 colgroup(); 2612 } 2613 break; 2614 case 9: 2615 { 2616 setState(408); 2617 dd(); 2618 } 2619 break; 2620 case 10: 2621 { 2622 setState(409); 2623 dt(); 2624 } 2625 break; 2626 case 11: 2627 { 2628 setState(410); 2629 head(); 2630 } 2631 break; 2632 case 12: 2633 { 2634 setState(411); 2635 html(); 2636 } 2637 break; 2638 case 13: 2639 { 2640 setState(412); 2641 option(); 2642 } 2643 break; 2644 case 14: 2645 { 2646 setState(413); 2647 tbody(); 2648 } 2649 break; 2650 case 15: 2651 { 2652 setState(414); 2653 thead(); 2654 } 2655 break; 2656 case 16: 2657 { 2658 setState(415); 2659 tfoot(); 2660 } 2661 break; 2662 case 17: 2663 { 2664 setState(416); 2665 pTagOpen(); 2666 } 2667 break; 2668 case 18: 2669 { 2670 setState(417); 2671 trTagOpen(); 2672 } 2673 break; 2674 case 19: 2675 { 2676 setState(418); 2677 tdTagOpen(); 2678 } 2679 break; 2680 case 20: 2681 { 2682 setState(419); 2683 thTagOpen(); 2684 } 2685 break; 2686 case 21: 2687 { 2688 setState(420); 2689 bodyTagOpen(); 2690 } 2691 break; 2692 case 22: 2693 { 2694 setState(421); 2695 colgroupTagOpen(); 2696 } 2697 break; 2698 case 23: 2699 { 2700 setState(422); 2701 ddTagOpen(); 2702 } 2703 break; 2704 case 24: 2705 { 2706 setState(423); 2707 dtTagOpen(); 2708 } 2709 break; 2710 case 25: 2711 { 2712 setState(424); 2713 headTagOpen(); 2714 } 2715 break; 2716 case 26: 2717 { 2718 setState(425); 2719 htmlTagOpen(); 2720 } 2721 break; 2722 case 27: 2723 { 2724 setState(426); 2725 optionTagOpen(); 2726 } 2727 break; 2728 case 28: 2729 { 2730 setState(427); 2731 tbodyTagOpen(); 2732 } 2733 break; 2734 case 29: 2735 { 2736 setState(428); 2737 theadTagOpen(); 2738 } 2739 break; 2740 case 30: 2741 { 2742 setState(429); 2743 tfootTagOpen(); 2744 } 2745 break; 2746 case 31: 2747 { 2748 { 2749 setState(430); 2750 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2751 setState(431); 2752 match(LEADING_ASTERISK); 2753 } 2754 } 2755 break; 2756 case 32: 2757 { 2758 setState(432); 2759 htmlComment(); 2760 } 2761 break; 2762 case 33: 2763 { 2764 setState(433); 2765 match(CDATA); 2766 } 2767 break; 2768 case 34: 2769 { 2770 setState(434); 2771 match(NEWLINE); 2772 } 2773 break; 2774 case 35: 2775 { 2776 setState(435); 2777 text(); 2778 } 2779 break; 2780 case 36: 2781 { 2782 setState(436); 2783 javadocInlineTag(); 2784 } 2785 break; 2786 } 2787 } 2788 } 2789 setState(441); 2790 _errHandler.sync(this); 2791 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 2792 } 2793 setState(442); 2794 liTagClose(); 2795 } 2796 } 2797 catch (RecognitionException re) { 2798 _localctx.exception = re; 2799 _errHandler.reportError(this, re); 2800 _errHandler.recover(this, re); 2801 } 2802 finally { 2803 exitRule(); 2804 } 2805 return _localctx; 2806 } 2807 2808 public static class TrTagOpenContext extends ParserRuleContext { 2809 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2810 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2811 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2812 public List<AttributeContext> attribute() { 2813 return getRuleContexts(AttributeContext.class); 2814 } 2815 public AttributeContext attribute(int i) { 2816 return getRuleContext(AttributeContext.class,i); 2817 } 2818 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2819 public TerminalNode NEWLINE(int i) { 2820 return getToken(JavadocParser.NEWLINE, i); 2821 } 2822 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2823 public TerminalNode LEADING_ASTERISK(int i) { 2824 return getToken(JavadocParser.LEADING_ASTERISK, i); 2825 } 2826 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2827 public TerminalNode WS(int i) { 2828 return getToken(JavadocParser.WS, i); 2829 } 2830 public TrTagOpenContext(ParserRuleContext parent, int invokingState) { 2831 super(parent, invokingState); 2832 } 2833 @Override public int getRuleIndex() { return RULE_trTagOpen; } 2834 @Override 2835 public void enterRule(ParseTreeListener listener) { 2836 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagOpen(this); 2837 } 2838 @Override 2839 public void exitRule(ParseTreeListener listener) { 2840 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagOpen(this); 2841 } 2842 @Override 2843 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2844 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagOpen(this); 2845 else return visitor.visitChildren(this); 2846 } 2847 } 2848 2849 public final TrTagOpenContext trTagOpen() throws RecognitionException { 2850 TrTagOpenContext _localctx = new TrTagOpenContext(_ctx, getState()); 2851 enterRule(_localctx, 24, RULE_trTagOpen); 2852 int _la; 2853 try { 2854 enterOuterAlt(_localctx, 1); 2855 { 2856 setState(444); 2857 match(OPEN); 2858 setState(445); 2859 match(TR_HTML_TAG_NAME); 2860 setState(452); 2861 _errHandler.sync(this); 2862 _la = _input.LA(1); 2863 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2864 { 2865 setState(450); 2866 switch (_input.LA(1)) { 2867 case HTML_TAG_NAME: 2868 { 2869 setState(446); 2870 attribute(); 2871 } 2872 break; 2873 case NEWLINE: 2874 { 2875 setState(447); 2876 match(NEWLINE); 2877 } 2878 break; 2879 case LEADING_ASTERISK: 2880 { 2881 setState(448); 2882 match(LEADING_ASTERISK); 2883 } 2884 break; 2885 case WS: 2886 { 2887 setState(449); 2888 match(WS); 2889 } 2890 break; 2891 default: 2892 throw new NoViableAltException(this); 2893 } 2894 } 2895 setState(454); 2896 _errHandler.sync(this); 2897 _la = _input.LA(1); 2898 } 2899 setState(455); 2900 match(CLOSE); 2901 } 2902 } 2903 catch (RecognitionException re) { 2904 _localctx.exception = re; 2905 _errHandler.reportError(this, re); 2906 _errHandler.recover(this, re); 2907 } 2908 finally { 2909 exitRule(); 2910 } 2911 return _localctx; 2912 } 2913 2914 public static class TrTagCloseContext extends ParserRuleContext { 2915 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2916 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2917 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2918 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2919 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2920 public TerminalNode NEWLINE(int i) { 2921 return getToken(JavadocParser.NEWLINE, i); 2922 } 2923 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2924 public TerminalNode LEADING_ASTERISK(int i) { 2925 return getToken(JavadocParser.LEADING_ASTERISK, i); 2926 } 2927 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2928 public TerminalNode WS(int i) { 2929 return getToken(JavadocParser.WS, i); 2930 } 2931 public TrTagCloseContext(ParserRuleContext parent, int invokingState) { 2932 super(parent, invokingState); 2933 } 2934 @Override public int getRuleIndex() { return RULE_trTagClose; } 2935 @Override 2936 public void enterRule(ParseTreeListener listener) { 2937 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagClose(this); 2938 } 2939 @Override 2940 public void exitRule(ParseTreeListener listener) { 2941 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagClose(this); 2942 } 2943 @Override 2944 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2945 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagClose(this); 2946 else return visitor.visitChildren(this); 2947 } 2948 } 2949 2950 public final TrTagCloseContext trTagClose() throws RecognitionException { 2951 TrTagCloseContext _localctx = new TrTagCloseContext(_ctx, getState()); 2952 enterRule(_localctx, 26, RULE_trTagClose); 2953 int _la; 2954 try { 2955 enterOuterAlt(_localctx, 1); 2956 { 2957 setState(457); 2958 match(OPEN); 2959 setState(458); 2960 match(SLASH); 2961 setState(459); 2962 match(TR_HTML_TAG_NAME); 2963 setState(463); 2964 _errHandler.sync(this); 2965 _la = _input.LA(1); 2966 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2967 { 2968 { 2969 setState(460); 2970 _la = _input.LA(1); 2971 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2972 _errHandler.recoverInline(this); 2973 } else { 2974 consume(); 2975 } 2976 } 2977 } 2978 setState(465); 2979 _errHandler.sync(this); 2980 _la = _input.LA(1); 2981 } 2982 setState(466); 2983 match(CLOSE); 2984 } 2985 } 2986 catch (RecognitionException re) { 2987 _localctx.exception = re; 2988 _errHandler.reportError(this, re); 2989 _errHandler.recover(this, re); 2990 } 2991 finally { 2992 exitRule(); 2993 } 2994 return _localctx; 2995 } 2996 2997 public static class TrContext extends ParserRuleContext { 2998 public TrTagOpenContext trTagOpen() { 2999 return getRuleContext(TrTagOpenContext.class,0); 3000 } 3001 public TrTagCloseContext trTagClose() { 3002 return getRuleContext(TrTagCloseContext.class,0); 3003 } 3004 public List<HtmlTagContext> htmlTag() { 3005 return getRuleContexts(HtmlTagContext.class); 3006 } 3007 public HtmlTagContext htmlTag(int i) { 3008 return getRuleContext(HtmlTagContext.class,i); 3009 } 3010 public List<SingletonTagContext> singletonTag() { 3011 return getRuleContexts(SingletonTagContext.class); 3012 } 3013 public SingletonTagContext singletonTag(int i) { 3014 return getRuleContext(SingletonTagContext.class,i); 3015 } 3016 public List<ParagraphContext> paragraph() { 3017 return getRuleContexts(ParagraphContext.class); 3018 } 3019 public ParagraphContext paragraph(int i) { 3020 return getRuleContext(ParagraphContext.class,i); 3021 } 3022 public List<LiContext> li() { 3023 return getRuleContexts(LiContext.class); 3024 } 3025 public LiContext li(int i) { 3026 return getRuleContext(LiContext.class,i); 3027 } 3028 public List<TdContext> td() { 3029 return getRuleContexts(TdContext.class); 3030 } 3031 public TdContext td(int i) { 3032 return getRuleContext(TdContext.class,i); 3033 } 3034 public List<ThContext> th() { 3035 return getRuleContexts(ThContext.class); 3036 } 3037 public ThContext th(int i) { 3038 return getRuleContext(ThContext.class,i); 3039 } 3040 public List<BodyContext> body() { 3041 return getRuleContexts(BodyContext.class); 3042 } 3043 public BodyContext body(int i) { 3044 return getRuleContext(BodyContext.class,i); 3045 } 3046 public List<ColgroupContext> colgroup() { 3047 return getRuleContexts(ColgroupContext.class); 3048 } 3049 public ColgroupContext colgroup(int i) { 3050 return getRuleContext(ColgroupContext.class,i); 3051 } 3052 public List<DdContext> dd() { 3053 return getRuleContexts(DdContext.class); 3054 } 3055 public DdContext dd(int i) { 3056 return getRuleContext(DdContext.class,i); 3057 } 3058 public List<DtContext> dt() { 3059 return getRuleContexts(DtContext.class); 3060 } 3061 public DtContext dt(int i) { 3062 return getRuleContext(DtContext.class,i); 3063 } 3064 public List<HeadContext> head() { 3065 return getRuleContexts(HeadContext.class); 3066 } 3067 public HeadContext head(int i) { 3068 return getRuleContext(HeadContext.class,i); 3069 } 3070 public List<HtmlContext> html() { 3071 return getRuleContexts(HtmlContext.class); 3072 } 3073 public HtmlContext html(int i) { 3074 return getRuleContext(HtmlContext.class,i); 3075 } 3076 public List<OptionContext> option() { 3077 return getRuleContexts(OptionContext.class); 3078 } 3079 public OptionContext option(int i) { 3080 return getRuleContext(OptionContext.class,i); 3081 } 3082 public List<TbodyContext> tbody() { 3083 return getRuleContexts(TbodyContext.class); 3084 } 3085 public TbodyContext tbody(int i) { 3086 return getRuleContext(TbodyContext.class,i); 3087 } 3088 public List<TheadContext> thead() { 3089 return getRuleContexts(TheadContext.class); 3090 } 3091 public TheadContext thead(int i) { 3092 return getRuleContext(TheadContext.class,i); 3093 } 3094 public List<TfootContext> tfoot() { 3095 return getRuleContexts(TfootContext.class); 3096 } 3097 public TfootContext tfoot(int i) { 3098 return getRuleContext(TfootContext.class,i); 3099 } 3100 public List<PTagOpenContext> pTagOpen() { 3101 return getRuleContexts(PTagOpenContext.class); 3102 } 3103 public PTagOpenContext pTagOpen(int i) { 3104 return getRuleContext(PTagOpenContext.class,i); 3105 } 3106 public List<LiTagOpenContext> liTagOpen() { 3107 return getRuleContexts(LiTagOpenContext.class); 3108 } 3109 public LiTagOpenContext liTagOpen(int i) { 3110 return getRuleContext(LiTagOpenContext.class,i); 3111 } 3112 public List<TdTagOpenContext> tdTagOpen() { 3113 return getRuleContexts(TdTagOpenContext.class); 3114 } 3115 public TdTagOpenContext tdTagOpen(int i) { 3116 return getRuleContext(TdTagOpenContext.class,i); 3117 } 3118 public List<ThTagOpenContext> thTagOpen() { 3119 return getRuleContexts(ThTagOpenContext.class); 3120 } 3121 public ThTagOpenContext thTagOpen(int i) { 3122 return getRuleContext(ThTagOpenContext.class,i); 3123 } 3124 public List<BodyTagOpenContext> bodyTagOpen() { 3125 return getRuleContexts(BodyTagOpenContext.class); 3126 } 3127 public BodyTagOpenContext bodyTagOpen(int i) { 3128 return getRuleContext(BodyTagOpenContext.class,i); 3129 } 3130 public List<ColgroupTagOpenContext> colgroupTagOpen() { 3131 return getRuleContexts(ColgroupTagOpenContext.class); 3132 } 3133 public ColgroupTagOpenContext colgroupTagOpen(int i) { 3134 return getRuleContext(ColgroupTagOpenContext.class,i); 3135 } 3136 public List<DdTagOpenContext> ddTagOpen() { 3137 return getRuleContexts(DdTagOpenContext.class); 3138 } 3139 public DdTagOpenContext ddTagOpen(int i) { 3140 return getRuleContext(DdTagOpenContext.class,i); 3141 } 3142 public List<DtTagOpenContext> dtTagOpen() { 3143 return getRuleContexts(DtTagOpenContext.class); 3144 } 3145 public DtTagOpenContext dtTagOpen(int i) { 3146 return getRuleContext(DtTagOpenContext.class,i); 3147 } 3148 public List<HeadTagOpenContext> headTagOpen() { 3149 return getRuleContexts(HeadTagOpenContext.class); 3150 } 3151 public HeadTagOpenContext headTagOpen(int i) { 3152 return getRuleContext(HeadTagOpenContext.class,i); 3153 } 3154 public List<HtmlTagOpenContext> htmlTagOpen() { 3155 return getRuleContexts(HtmlTagOpenContext.class); 3156 } 3157 public HtmlTagOpenContext htmlTagOpen(int i) { 3158 return getRuleContext(HtmlTagOpenContext.class,i); 3159 } 3160 public List<OptionTagOpenContext> optionTagOpen() { 3161 return getRuleContexts(OptionTagOpenContext.class); 3162 } 3163 public OptionTagOpenContext optionTagOpen(int i) { 3164 return getRuleContext(OptionTagOpenContext.class,i); 3165 } 3166 public List<TbodyTagOpenContext> tbodyTagOpen() { 3167 return getRuleContexts(TbodyTagOpenContext.class); 3168 } 3169 public TbodyTagOpenContext tbodyTagOpen(int i) { 3170 return getRuleContext(TbodyTagOpenContext.class,i); 3171 } 3172 public List<TheadTagOpenContext> theadTagOpen() { 3173 return getRuleContexts(TheadTagOpenContext.class); 3174 } 3175 public TheadTagOpenContext theadTagOpen(int i) { 3176 return getRuleContext(TheadTagOpenContext.class,i); 3177 } 3178 public List<TfootTagOpenContext> tfootTagOpen() { 3179 return getRuleContexts(TfootTagOpenContext.class); 3180 } 3181 public TfootTagOpenContext tfootTagOpen(int i) { 3182 return getRuleContext(TfootTagOpenContext.class,i); 3183 } 3184 public List<HtmlCommentContext> htmlComment() { 3185 return getRuleContexts(HtmlCommentContext.class); 3186 } 3187 public HtmlCommentContext htmlComment(int i) { 3188 return getRuleContext(HtmlCommentContext.class,i); 3189 } 3190 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3191 public TerminalNode CDATA(int i) { 3192 return getToken(JavadocParser.CDATA, i); 3193 } 3194 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3195 public TerminalNode NEWLINE(int i) { 3196 return getToken(JavadocParser.NEWLINE, i); 3197 } 3198 public List<TextContext> text() { 3199 return getRuleContexts(TextContext.class); 3200 } 3201 public TextContext text(int i) { 3202 return getRuleContext(TextContext.class,i); 3203 } 3204 public List<JavadocInlineTagContext> javadocInlineTag() { 3205 return getRuleContexts(JavadocInlineTagContext.class); 3206 } 3207 public JavadocInlineTagContext javadocInlineTag(int i) { 3208 return getRuleContext(JavadocInlineTagContext.class,i); 3209 } 3210 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3211 public TerminalNode LEADING_ASTERISK(int i) { 3212 return getToken(JavadocParser.LEADING_ASTERISK, i); 3213 } 3214 public TrContext(ParserRuleContext parent, int invokingState) { 3215 super(parent, invokingState); 3216 } 3217 @Override public int getRuleIndex() { return RULE_tr; } 3218 @Override 3219 public void enterRule(ParseTreeListener listener) { 3220 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTr(this); 3221 } 3222 @Override 3223 public void exitRule(ParseTreeListener listener) { 3224 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTr(this); 3225 } 3226 @Override 3227 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3228 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTr(this); 3229 else return visitor.visitChildren(this); 3230 } 3231 } 3232 3233 public final TrContext tr() throws RecognitionException { 3234 TrContext _localctx = new TrContext(_ctx, getState()); 3235 enterRule(_localctx, 28, RULE_tr); 3236 try { 3237 int _alt; 3238 enterOuterAlt(_localctx, 1); 3239 { 3240 setState(468); 3241 trTagOpen(); 3242 setState(508); 3243 _errHandler.sync(this); 3244 _alt = getInterpreter().adaptivePredict(_input,31,_ctx); 3245 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3246 if ( _alt==1 ) { 3247 { 3248 setState(506); 3249 _errHandler.sync(this); 3250 switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) { 3251 case 1: 3252 { 3253 setState(469); 3254 htmlTag(); 3255 } 3256 break; 3257 case 2: 3258 { 3259 setState(470); 3260 singletonTag(); 3261 } 3262 break; 3263 case 3: 3264 { 3265 setState(471); 3266 paragraph(); 3267 } 3268 break; 3269 case 4: 3270 { 3271 setState(472); 3272 li(); 3273 } 3274 break; 3275 case 5: 3276 { 3277 setState(473); 3278 td(); 3279 } 3280 break; 3281 case 6: 3282 { 3283 setState(474); 3284 th(); 3285 } 3286 break; 3287 case 7: 3288 { 3289 setState(475); 3290 body(); 3291 } 3292 break; 3293 case 8: 3294 { 3295 setState(476); 3296 colgroup(); 3297 } 3298 break; 3299 case 9: 3300 { 3301 setState(477); 3302 dd(); 3303 } 3304 break; 3305 case 10: 3306 { 3307 setState(478); 3308 dt(); 3309 } 3310 break; 3311 case 11: 3312 { 3313 setState(479); 3314 head(); 3315 } 3316 break; 3317 case 12: 3318 { 3319 setState(480); 3320 html(); 3321 } 3322 break; 3323 case 13: 3324 { 3325 setState(481); 3326 option(); 3327 } 3328 break; 3329 case 14: 3330 { 3331 setState(482); 3332 tbody(); 3333 } 3334 break; 3335 case 15: 3336 { 3337 setState(483); 3338 thead(); 3339 } 3340 break; 3341 case 16: 3342 { 3343 setState(484); 3344 tfoot(); 3345 } 3346 break; 3347 case 17: 3348 { 3349 setState(485); 3350 pTagOpen(); 3351 } 3352 break; 3353 case 18: 3354 { 3355 setState(486); 3356 liTagOpen(); 3357 } 3358 break; 3359 case 19: 3360 { 3361 setState(487); 3362 tdTagOpen(); 3363 } 3364 break; 3365 case 20: 3366 { 3367 setState(488); 3368 thTagOpen(); 3369 } 3370 break; 3371 case 21: 3372 { 3373 setState(489); 3374 bodyTagOpen(); 3375 } 3376 break; 3377 case 22: 3378 { 3379 setState(490); 3380 colgroupTagOpen(); 3381 } 3382 break; 3383 case 23: 3384 { 3385 setState(491); 3386 ddTagOpen(); 3387 } 3388 break; 3389 case 24: 3390 { 3391 setState(492); 3392 dtTagOpen(); 3393 } 3394 break; 3395 case 25: 3396 { 3397 setState(493); 3398 headTagOpen(); 3399 } 3400 break; 3401 case 26: 3402 { 3403 setState(494); 3404 htmlTagOpen(); 3405 } 3406 break; 3407 case 27: 3408 { 3409 setState(495); 3410 optionTagOpen(); 3411 } 3412 break; 3413 case 28: 3414 { 3415 setState(496); 3416 tbodyTagOpen(); 3417 } 3418 break; 3419 case 29: 3420 { 3421 setState(497); 3422 theadTagOpen(); 3423 } 3424 break; 3425 case 30: 3426 { 3427 setState(498); 3428 tfootTagOpen(); 3429 } 3430 break; 3431 case 31: 3432 { 3433 { 3434 setState(499); 3435 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 3436 setState(500); 3437 match(LEADING_ASTERISK); 3438 } 3439 } 3440 break; 3441 case 32: 3442 { 3443 setState(501); 3444 htmlComment(); 3445 } 3446 break; 3447 case 33: 3448 { 3449 setState(502); 3450 match(CDATA); 3451 } 3452 break; 3453 case 34: 3454 { 3455 setState(503); 3456 match(NEWLINE); 3457 } 3458 break; 3459 case 35: 3460 { 3461 setState(504); 3462 text(); 3463 } 3464 break; 3465 case 36: 3466 { 3467 setState(505); 3468 javadocInlineTag(); 3469 } 3470 break; 3471 } 3472 } 3473 } 3474 setState(510); 3475 _errHandler.sync(this); 3476 _alt = getInterpreter().adaptivePredict(_input,31,_ctx); 3477 } 3478 setState(511); 3479 trTagClose(); 3480 } 3481 } 3482 catch (RecognitionException re) { 3483 _localctx.exception = re; 3484 _errHandler.reportError(this, re); 3485 _errHandler.recover(this, re); 3486 } 3487 finally { 3488 exitRule(); 3489 } 3490 return _localctx; 3491 } 3492 3493 public static class TdTagOpenContext extends ParserRuleContext { 3494 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 3495 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3496 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 3497 public List<AttributeContext> attribute() { 3498 return getRuleContexts(AttributeContext.class); 3499 } 3500 public AttributeContext attribute(int i) { 3501 return getRuleContext(AttributeContext.class,i); 3502 } 3503 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3504 public TerminalNode NEWLINE(int i) { 3505 return getToken(JavadocParser.NEWLINE, i); 3506 } 3507 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3508 public TerminalNode LEADING_ASTERISK(int i) { 3509 return getToken(JavadocParser.LEADING_ASTERISK, i); 3510 } 3511 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3512 public TerminalNode WS(int i) { 3513 return getToken(JavadocParser.WS, i); 3514 } 3515 public TdTagOpenContext(ParserRuleContext parent, int invokingState) { 3516 super(parent, invokingState); 3517 } 3518 @Override public int getRuleIndex() { return RULE_tdTagOpen; } 3519 @Override 3520 public void enterRule(ParseTreeListener listener) { 3521 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagOpen(this); 3522 } 3523 @Override 3524 public void exitRule(ParseTreeListener listener) { 3525 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagOpen(this); 3526 } 3527 @Override 3528 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3529 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagOpen(this); 3530 else return visitor.visitChildren(this); 3531 } 3532 } 3533 3534 public final TdTagOpenContext tdTagOpen() throws RecognitionException { 3535 TdTagOpenContext _localctx = new TdTagOpenContext(_ctx, getState()); 3536 enterRule(_localctx, 30, RULE_tdTagOpen); 3537 int _la; 3538 try { 3539 enterOuterAlt(_localctx, 1); 3540 { 3541 setState(513); 3542 match(OPEN); 3543 setState(514); 3544 match(TD_HTML_TAG_NAME); 3545 setState(521); 3546 _errHandler.sync(this); 3547 _la = _input.LA(1); 3548 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 3549 { 3550 setState(519); 3551 switch (_input.LA(1)) { 3552 case HTML_TAG_NAME: 3553 { 3554 setState(515); 3555 attribute(); 3556 } 3557 break; 3558 case NEWLINE: 3559 { 3560 setState(516); 3561 match(NEWLINE); 3562 } 3563 break; 3564 case LEADING_ASTERISK: 3565 { 3566 setState(517); 3567 match(LEADING_ASTERISK); 3568 } 3569 break; 3570 case WS: 3571 { 3572 setState(518); 3573 match(WS); 3574 } 3575 break; 3576 default: 3577 throw new NoViableAltException(this); 3578 } 3579 } 3580 setState(523); 3581 _errHandler.sync(this); 3582 _la = _input.LA(1); 3583 } 3584 setState(524); 3585 match(CLOSE); 3586 } 3587 } 3588 catch (RecognitionException re) { 3589 _localctx.exception = re; 3590 _errHandler.reportError(this, re); 3591 _errHandler.recover(this, re); 3592 } 3593 finally { 3594 exitRule(); 3595 } 3596 return _localctx; 3597 } 3598 3599 public static class TdTagCloseContext extends ParserRuleContext { 3600 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 3601 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 3602 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3603 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 3604 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3605 public TerminalNode NEWLINE(int i) { 3606 return getToken(JavadocParser.NEWLINE, i); 3607 } 3608 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3609 public TerminalNode LEADING_ASTERISK(int i) { 3610 return getToken(JavadocParser.LEADING_ASTERISK, i); 3611 } 3612 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3613 public TerminalNode WS(int i) { 3614 return getToken(JavadocParser.WS, i); 3615 } 3616 public TdTagCloseContext(ParserRuleContext parent, int invokingState) { 3617 super(parent, invokingState); 3618 } 3619 @Override public int getRuleIndex() { return RULE_tdTagClose; } 3620 @Override 3621 public void enterRule(ParseTreeListener listener) { 3622 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagClose(this); 3623 } 3624 @Override 3625 public void exitRule(ParseTreeListener listener) { 3626 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagClose(this); 3627 } 3628 @Override 3629 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3630 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagClose(this); 3631 else return visitor.visitChildren(this); 3632 } 3633 } 3634 3635 public final TdTagCloseContext tdTagClose() throws RecognitionException { 3636 TdTagCloseContext _localctx = new TdTagCloseContext(_ctx, getState()); 3637 enterRule(_localctx, 32, RULE_tdTagClose); 3638 int _la; 3639 try { 3640 enterOuterAlt(_localctx, 1); 3641 { 3642 setState(526); 3643 match(OPEN); 3644 setState(527); 3645 match(SLASH); 3646 setState(528); 3647 match(TD_HTML_TAG_NAME); 3648 setState(532); 3649 _errHandler.sync(this); 3650 _la = _input.LA(1); 3651 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3652 { 3653 { 3654 setState(529); 3655 _la = _input.LA(1); 3656 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3657 _errHandler.recoverInline(this); 3658 } else { 3659 consume(); 3660 } 3661 } 3662 } 3663 setState(534); 3664 _errHandler.sync(this); 3665 _la = _input.LA(1); 3666 } 3667 setState(535); 3668 match(CLOSE); 3669 } 3670 } 3671 catch (RecognitionException re) { 3672 _localctx.exception = re; 3673 _errHandler.reportError(this, re); 3674 _errHandler.recover(this, re); 3675 } 3676 finally { 3677 exitRule(); 3678 } 3679 return _localctx; 3680 } 3681 3682 public static class TdContext extends ParserRuleContext { 3683 public List<TdTagOpenContext> tdTagOpen() { 3684 return getRuleContexts(TdTagOpenContext.class); 3685 } 3686 public TdTagOpenContext tdTagOpen(int i) { 3687 return getRuleContext(TdTagOpenContext.class,i); 3688 } 3689 public TdTagCloseContext tdTagClose() { 3690 return getRuleContext(TdTagCloseContext.class,0); 3691 } 3692 public List<HtmlTagContext> htmlTag() { 3693 return getRuleContexts(HtmlTagContext.class); 3694 } 3695 public HtmlTagContext htmlTag(int i) { 3696 return getRuleContext(HtmlTagContext.class,i); 3697 } 3698 public List<SingletonTagContext> singletonTag() { 3699 return getRuleContexts(SingletonTagContext.class); 3700 } 3701 public SingletonTagContext singletonTag(int i) { 3702 return getRuleContext(SingletonTagContext.class,i); 3703 } 3704 public List<ParagraphContext> paragraph() { 3705 return getRuleContexts(ParagraphContext.class); 3706 } 3707 public ParagraphContext paragraph(int i) { 3708 return getRuleContext(ParagraphContext.class,i); 3709 } 3710 public List<LiContext> li() { 3711 return getRuleContexts(LiContext.class); 3712 } 3713 public LiContext li(int i) { 3714 return getRuleContext(LiContext.class,i); 3715 } 3716 public List<TrContext> tr() { 3717 return getRuleContexts(TrContext.class); 3718 } 3719 public TrContext tr(int i) { 3720 return getRuleContext(TrContext.class,i); 3721 } 3722 public List<ThContext> th() { 3723 return getRuleContexts(ThContext.class); 3724 } 3725 public ThContext th(int i) { 3726 return getRuleContext(ThContext.class,i); 3727 } 3728 public List<BodyContext> body() { 3729 return getRuleContexts(BodyContext.class); 3730 } 3731 public BodyContext body(int i) { 3732 return getRuleContext(BodyContext.class,i); 3733 } 3734 public List<ColgroupContext> colgroup() { 3735 return getRuleContexts(ColgroupContext.class); 3736 } 3737 public ColgroupContext colgroup(int i) { 3738 return getRuleContext(ColgroupContext.class,i); 3739 } 3740 public List<DdContext> dd() { 3741 return getRuleContexts(DdContext.class); 3742 } 3743 public DdContext dd(int i) { 3744 return getRuleContext(DdContext.class,i); 3745 } 3746 public List<DtContext> dt() { 3747 return getRuleContexts(DtContext.class); 3748 } 3749 public DtContext dt(int i) { 3750 return getRuleContext(DtContext.class,i); 3751 } 3752 public List<HeadContext> head() { 3753 return getRuleContexts(HeadContext.class); 3754 } 3755 public HeadContext head(int i) { 3756 return getRuleContext(HeadContext.class,i); 3757 } 3758 public List<HtmlContext> html() { 3759 return getRuleContexts(HtmlContext.class); 3760 } 3761 public HtmlContext html(int i) { 3762 return getRuleContext(HtmlContext.class,i); 3763 } 3764 public List<OptionContext> option() { 3765 return getRuleContexts(OptionContext.class); 3766 } 3767 public OptionContext option(int i) { 3768 return getRuleContext(OptionContext.class,i); 3769 } 3770 public List<TbodyContext> tbody() { 3771 return getRuleContexts(TbodyContext.class); 3772 } 3773 public TbodyContext tbody(int i) { 3774 return getRuleContext(TbodyContext.class,i); 3775 } 3776 public List<TheadContext> thead() { 3777 return getRuleContexts(TheadContext.class); 3778 } 3779 public TheadContext thead(int i) { 3780 return getRuleContext(TheadContext.class,i); 3781 } 3782 public List<TfootContext> tfoot() { 3783 return getRuleContexts(TfootContext.class); 3784 } 3785 public TfootContext tfoot(int i) { 3786 return getRuleContext(TfootContext.class,i); 3787 } 3788 public List<PTagOpenContext> pTagOpen() { 3789 return getRuleContexts(PTagOpenContext.class); 3790 } 3791 public PTagOpenContext pTagOpen(int i) { 3792 return getRuleContext(PTagOpenContext.class,i); 3793 } 3794 public List<LiTagOpenContext> liTagOpen() { 3795 return getRuleContexts(LiTagOpenContext.class); 3796 } 3797 public LiTagOpenContext liTagOpen(int i) { 3798 return getRuleContext(LiTagOpenContext.class,i); 3799 } 3800 public List<ThTagOpenContext> thTagOpen() { 3801 return getRuleContexts(ThTagOpenContext.class); 3802 } 3803 public ThTagOpenContext thTagOpen(int i) { 3804 return getRuleContext(ThTagOpenContext.class,i); 3805 } 3806 public List<BodyTagOpenContext> bodyTagOpen() { 3807 return getRuleContexts(BodyTagOpenContext.class); 3808 } 3809 public BodyTagOpenContext bodyTagOpen(int i) { 3810 return getRuleContext(BodyTagOpenContext.class,i); 3811 } 3812 public List<ColgroupTagOpenContext> colgroupTagOpen() { 3813 return getRuleContexts(ColgroupTagOpenContext.class); 3814 } 3815 public ColgroupTagOpenContext colgroupTagOpen(int i) { 3816 return getRuleContext(ColgroupTagOpenContext.class,i); 3817 } 3818 public List<DdTagOpenContext> ddTagOpen() { 3819 return getRuleContexts(DdTagOpenContext.class); 3820 } 3821 public DdTagOpenContext ddTagOpen(int i) { 3822 return getRuleContext(DdTagOpenContext.class,i); 3823 } 3824 public List<DtTagOpenContext> dtTagOpen() { 3825 return getRuleContexts(DtTagOpenContext.class); 3826 } 3827 public DtTagOpenContext dtTagOpen(int i) { 3828 return getRuleContext(DtTagOpenContext.class,i); 3829 } 3830 public List<HeadTagOpenContext> headTagOpen() { 3831 return getRuleContexts(HeadTagOpenContext.class); 3832 } 3833 public HeadTagOpenContext headTagOpen(int i) { 3834 return getRuleContext(HeadTagOpenContext.class,i); 3835 } 3836 public List<HtmlTagOpenContext> htmlTagOpen() { 3837 return getRuleContexts(HtmlTagOpenContext.class); 3838 } 3839 public HtmlTagOpenContext htmlTagOpen(int i) { 3840 return getRuleContext(HtmlTagOpenContext.class,i); 3841 } 3842 public List<OptionTagOpenContext> optionTagOpen() { 3843 return getRuleContexts(OptionTagOpenContext.class); 3844 } 3845 public OptionTagOpenContext optionTagOpen(int i) { 3846 return getRuleContext(OptionTagOpenContext.class,i); 3847 } 3848 public List<TbodyTagOpenContext> tbodyTagOpen() { 3849 return getRuleContexts(TbodyTagOpenContext.class); 3850 } 3851 public TbodyTagOpenContext tbodyTagOpen(int i) { 3852 return getRuleContext(TbodyTagOpenContext.class,i); 3853 } 3854 public List<TheadTagOpenContext> theadTagOpen() { 3855 return getRuleContexts(TheadTagOpenContext.class); 3856 } 3857 public TheadTagOpenContext theadTagOpen(int i) { 3858 return getRuleContext(TheadTagOpenContext.class,i); 3859 } 3860 public List<TfootTagOpenContext> tfootTagOpen() { 3861 return getRuleContexts(TfootTagOpenContext.class); 3862 } 3863 public TfootTagOpenContext tfootTagOpen(int i) { 3864 return getRuleContext(TfootTagOpenContext.class,i); 3865 } 3866 public List<HtmlCommentContext> htmlComment() { 3867 return getRuleContexts(HtmlCommentContext.class); 3868 } 3869 public HtmlCommentContext htmlComment(int i) { 3870 return getRuleContext(HtmlCommentContext.class,i); 3871 } 3872 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3873 public TerminalNode CDATA(int i) { 3874 return getToken(JavadocParser.CDATA, i); 3875 } 3876 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3877 public TerminalNode NEWLINE(int i) { 3878 return getToken(JavadocParser.NEWLINE, i); 3879 } 3880 public List<TextContext> text() { 3881 return getRuleContexts(TextContext.class); 3882 } 3883 public TextContext text(int i) { 3884 return getRuleContext(TextContext.class,i); 3885 } 3886 public List<JavadocInlineTagContext> javadocInlineTag() { 3887 return getRuleContexts(JavadocInlineTagContext.class); 3888 } 3889 public JavadocInlineTagContext javadocInlineTag(int i) { 3890 return getRuleContext(JavadocInlineTagContext.class,i); 3891 } 3892 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3893 public TerminalNode LEADING_ASTERISK(int i) { 3894 return getToken(JavadocParser.LEADING_ASTERISK, i); 3895 } 3896 public TdContext(ParserRuleContext parent, int invokingState) { 3897 super(parent, invokingState); 3898 } 3899 @Override public int getRuleIndex() { return RULE_td; } 3900 @Override 3901 public void enterRule(ParseTreeListener listener) { 3902 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTd(this); 3903 } 3904 @Override 3905 public void exitRule(ParseTreeListener listener) { 3906 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTd(this); 3907 } 3908 @Override 3909 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3910 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTd(this); 3911 else return visitor.visitChildren(this); 3912 } 3913 } 3914 3915 public final TdContext td() throws RecognitionException { 3916 TdContext _localctx = new TdContext(_ctx, getState()); 3917 enterRule(_localctx, 34, RULE_td); 3918 try { 3919 int _alt; 3920 enterOuterAlt(_localctx, 1); 3921 { 3922 setState(537); 3923 tdTagOpen(); 3924 setState(577); 3925 _errHandler.sync(this); 3926 _alt = getInterpreter().adaptivePredict(_input,36,_ctx); 3927 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3928 if ( _alt==1 ) { 3929 { 3930 setState(575); 3931 _errHandler.sync(this); 3932 switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { 3933 case 1: 3934 { 3935 setState(538); 3936 htmlTag(); 3937 } 3938 break; 3939 case 2: 3940 { 3941 setState(539); 3942 singletonTag(); 3943 } 3944 break; 3945 case 3: 3946 { 3947 setState(540); 3948 paragraph(); 3949 } 3950 break; 3951 case 4: 3952 { 3953 setState(541); 3954 li(); 3955 } 3956 break; 3957 case 5: 3958 { 3959 setState(542); 3960 tr(); 3961 } 3962 break; 3963 case 6: 3964 { 3965 setState(543); 3966 th(); 3967 } 3968 break; 3969 case 7: 3970 { 3971 setState(544); 3972 body(); 3973 } 3974 break; 3975 case 8: 3976 { 3977 setState(545); 3978 colgroup(); 3979 } 3980 break; 3981 case 9: 3982 { 3983 setState(546); 3984 dd(); 3985 } 3986 break; 3987 case 10: 3988 { 3989 setState(547); 3990 dt(); 3991 } 3992 break; 3993 case 11: 3994 { 3995 setState(548); 3996 head(); 3997 } 3998 break; 3999 case 12: 4000 { 4001 setState(549); 4002 html(); 4003 } 4004 break; 4005 case 13: 4006 { 4007 setState(550); 4008 option(); 4009 } 4010 break; 4011 case 14: 4012 { 4013 setState(551); 4014 tbody(); 4015 } 4016 break; 4017 case 15: 4018 { 4019 setState(552); 4020 thead(); 4021 } 4022 break; 4023 case 16: 4024 { 4025 setState(553); 4026 tfoot(); 4027 } 4028 break; 4029 case 17: 4030 { 4031 setState(554); 4032 pTagOpen(); 4033 } 4034 break; 4035 case 18: 4036 { 4037 setState(555); 4038 liTagOpen(); 4039 } 4040 break; 4041 case 19: 4042 { 4043 setState(556); 4044 tdTagOpen(); 4045 } 4046 break; 4047 case 20: 4048 { 4049 setState(557); 4050 thTagOpen(); 4051 } 4052 break; 4053 case 21: 4054 { 4055 setState(558); 4056 bodyTagOpen(); 4057 } 4058 break; 4059 case 22: 4060 { 4061 setState(559); 4062 colgroupTagOpen(); 4063 } 4064 break; 4065 case 23: 4066 { 4067 setState(560); 4068 ddTagOpen(); 4069 } 4070 break; 4071 case 24: 4072 { 4073 setState(561); 4074 dtTagOpen(); 4075 } 4076 break; 4077 case 25: 4078 { 4079 setState(562); 4080 headTagOpen(); 4081 } 4082 break; 4083 case 26: 4084 { 4085 setState(563); 4086 htmlTagOpen(); 4087 } 4088 break; 4089 case 27: 4090 { 4091 setState(564); 4092 optionTagOpen(); 4093 } 4094 break; 4095 case 28: 4096 { 4097 setState(565); 4098 tbodyTagOpen(); 4099 } 4100 break; 4101 case 29: 4102 { 4103 setState(566); 4104 theadTagOpen(); 4105 } 4106 break; 4107 case 30: 4108 { 4109 setState(567); 4110 tfootTagOpen(); 4111 } 4112 break; 4113 case 31: 4114 { 4115 { 4116 setState(568); 4117 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4118 setState(569); 4119 match(LEADING_ASTERISK); 4120 } 4121 } 4122 break; 4123 case 32: 4124 { 4125 setState(570); 4126 htmlComment(); 4127 } 4128 break; 4129 case 33: 4130 { 4131 setState(571); 4132 match(CDATA); 4133 } 4134 break; 4135 case 34: 4136 { 4137 setState(572); 4138 match(NEWLINE); 4139 } 4140 break; 4141 case 35: 4142 { 4143 setState(573); 4144 text(); 4145 } 4146 break; 4147 case 36: 4148 { 4149 setState(574); 4150 javadocInlineTag(); 4151 } 4152 break; 4153 } 4154 } 4155 } 4156 setState(579); 4157 _errHandler.sync(this); 4158 _alt = getInterpreter().adaptivePredict(_input,36,_ctx); 4159 } 4160 setState(580); 4161 tdTagClose(); 4162 } 4163 } 4164 catch (RecognitionException re) { 4165 _localctx.exception = re; 4166 _errHandler.reportError(this, re); 4167 _errHandler.recover(this, re); 4168 } 4169 finally { 4170 exitRule(); 4171 } 4172 return _localctx; 4173 } 4174 4175 public static class ThTagOpenContext extends ParserRuleContext { 4176 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4177 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4178 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4179 public List<AttributeContext> attribute() { 4180 return getRuleContexts(AttributeContext.class); 4181 } 4182 public AttributeContext attribute(int i) { 4183 return getRuleContext(AttributeContext.class,i); 4184 } 4185 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4186 public TerminalNode NEWLINE(int i) { 4187 return getToken(JavadocParser.NEWLINE, i); 4188 } 4189 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4190 public TerminalNode LEADING_ASTERISK(int i) { 4191 return getToken(JavadocParser.LEADING_ASTERISK, i); 4192 } 4193 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4194 public TerminalNode WS(int i) { 4195 return getToken(JavadocParser.WS, i); 4196 } 4197 public ThTagOpenContext(ParserRuleContext parent, int invokingState) { 4198 super(parent, invokingState); 4199 } 4200 @Override public int getRuleIndex() { return RULE_thTagOpen; } 4201 @Override 4202 public void enterRule(ParseTreeListener listener) { 4203 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagOpen(this); 4204 } 4205 @Override 4206 public void exitRule(ParseTreeListener listener) { 4207 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagOpen(this); 4208 } 4209 @Override 4210 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4211 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagOpen(this); 4212 else return visitor.visitChildren(this); 4213 } 4214 } 4215 4216 public final ThTagOpenContext thTagOpen() throws RecognitionException { 4217 ThTagOpenContext _localctx = new ThTagOpenContext(_ctx, getState()); 4218 enterRule(_localctx, 36, RULE_thTagOpen); 4219 int _la; 4220 try { 4221 enterOuterAlt(_localctx, 1); 4222 { 4223 setState(582); 4224 match(OPEN); 4225 setState(583); 4226 match(TH_HTML_TAG_NAME); 4227 setState(590); 4228 _errHandler.sync(this); 4229 _la = _input.LA(1); 4230 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4231 { 4232 setState(588); 4233 switch (_input.LA(1)) { 4234 case HTML_TAG_NAME: 4235 { 4236 setState(584); 4237 attribute(); 4238 } 4239 break; 4240 case NEWLINE: 4241 { 4242 setState(585); 4243 match(NEWLINE); 4244 } 4245 break; 4246 case LEADING_ASTERISK: 4247 { 4248 setState(586); 4249 match(LEADING_ASTERISK); 4250 } 4251 break; 4252 case WS: 4253 { 4254 setState(587); 4255 match(WS); 4256 } 4257 break; 4258 default: 4259 throw new NoViableAltException(this); 4260 } 4261 } 4262 setState(592); 4263 _errHandler.sync(this); 4264 _la = _input.LA(1); 4265 } 4266 setState(593); 4267 match(CLOSE); 4268 } 4269 } 4270 catch (RecognitionException re) { 4271 _localctx.exception = re; 4272 _errHandler.reportError(this, re); 4273 _errHandler.recover(this, re); 4274 } 4275 finally { 4276 exitRule(); 4277 } 4278 return _localctx; 4279 } 4280 4281 public static class ThTagCloseContext extends ParserRuleContext { 4282 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4283 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4284 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4285 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4286 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4287 public TerminalNode NEWLINE(int i) { 4288 return getToken(JavadocParser.NEWLINE, i); 4289 } 4290 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4291 public TerminalNode LEADING_ASTERISK(int i) { 4292 return getToken(JavadocParser.LEADING_ASTERISK, i); 4293 } 4294 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4295 public TerminalNode WS(int i) { 4296 return getToken(JavadocParser.WS, i); 4297 } 4298 public ThTagCloseContext(ParserRuleContext parent, int invokingState) { 4299 super(parent, invokingState); 4300 } 4301 @Override public int getRuleIndex() { return RULE_thTagClose; } 4302 @Override 4303 public void enterRule(ParseTreeListener listener) { 4304 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagClose(this); 4305 } 4306 @Override 4307 public void exitRule(ParseTreeListener listener) { 4308 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagClose(this); 4309 } 4310 @Override 4311 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4312 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagClose(this); 4313 else return visitor.visitChildren(this); 4314 } 4315 } 4316 4317 public final ThTagCloseContext thTagClose() throws RecognitionException { 4318 ThTagCloseContext _localctx = new ThTagCloseContext(_ctx, getState()); 4319 enterRule(_localctx, 38, RULE_thTagClose); 4320 int _la; 4321 try { 4322 enterOuterAlt(_localctx, 1); 4323 { 4324 setState(595); 4325 match(OPEN); 4326 setState(596); 4327 match(SLASH); 4328 setState(597); 4329 match(TH_HTML_TAG_NAME); 4330 setState(601); 4331 _errHandler.sync(this); 4332 _la = _input.LA(1); 4333 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 4334 { 4335 { 4336 setState(598); 4337 _la = _input.LA(1); 4338 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 4339 _errHandler.recoverInline(this); 4340 } else { 4341 consume(); 4342 } 4343 } 4344 } 4345 setState(603); 4346 _errHandler.sync(this); 4347 _la = _input.LA(1); 4348 } 4349 setState(604); 4350 match(CLOSE); 4351 } 4352 } 4353 catch (RecognitionException re) { 4354 _localctx.exception = re; 4355 _errHandler.reportError(this, re); 4356 _errHandler.recover(this, re); 4357 } 4358 finally { 4359 exitRule(); 4360 } 4361 return _localctx; 4362 } 4363 4364 public static class ThContext extends ParserRuleContext { 4365 public ThTagOpenContext thTagOpen() { 4366 return getRuleContext(ThTagOpenContext.class,0); 4367 } 4368 public ThTagCloseContext thTagClose() { 4369 return getRuleContext(ThTagCloseContext.class,0); 4370 } 4371 public List<HtmlTagContext> htmlTag() { 4372 return getRuleContexts(HtmlTagContext.class); 4373 } 4374 public HtmlTagContext htmlTag(int i) { 4375 return getRuleContext(HtmlTagContext.class,i); 4376 } 4377 public List<SingletonTagContext> singletonTag() { 4378 return getRuleContexts(SingletonTagContext.class); 4379 } 4380 public SingletonTagContext singletonTag(int i) { 4381 return getRuleContext(SingletonTagContext.class,i); 4382 } 4383 public List<ParagraphContext> paragraph() { 4384 return getRuleContexts(ParagraphContext.class); 4385 } 4386 public ParagraphContext paragraph(int i) { 4387 return getRuleContext(ParagraphContext.class,i); 4388 } 4389 public List<LiContext> li() { 4390 return getRuleContexts(LiContext.class); 4391 } 4392 public LiContext li(int i) { 4393 return getRuleContext(LiContext.class,i); 4394 } 4395 public List<TrContext> tr() { 4396 return getRuleContexts(TrContext.class); 4397 } 4398 public TrContext tr(int i) { 4399 return getRuleContext(TrContext.class,i); 4400 } 4401 public List<TdContext> td() { 4402 return getRuleContexts(TdContext.class); 4403 } 4404 public TdContext td(int i) { 4405 return getRuleContext(TdContext.class,i); 4406 } 4407 public List<BodyContext> body() { 4408 return getRuleContexts(BodyContext.class); 4409 } 4410 public BodyContext body(int i) { 4411 return getRuleContext(BodyContext.class,i); 4412 } 4413 public List<ColgroupContext> colgroup() { 4414 return getRuleContexts(ColgroupContext.class); 4415 } 4416 public ColgroupContext colgroup(int i) { 4417 return getRuleContext(ColgroupContext.class,i); 4418 } 4419 public List<DdContext> dd() { 4420 return getRuleContexts(DdContext.class); 4421 } 4422 public DdContext dd(int i) { 4423 return getRuleContext(DdContext.class,i); 4424 } 4425 public List<DtContext> dt() { 4426 return getRuleContexts(DtContext.class); 4427 } 4428 public DtContext dt(int i) { 4429 return getRuleContext(DtContext.class,i); 4430 } 4431 public List<HeadContext> head() { 4432 return getRuleContexts(HeadContext.class); 4433 } 4434 public HeadContext head(int i) { 4435 return getRuleContext(HeadContext.class,i); 4436 } 4437 public List<HtmlContext> html() { 4438 return getRuleContexts(HtmlContext.class); 4439 } 4440 public HtmlContext html(int i) { 4441 return getRuleContext(HtmlContext.class,i); 4442 } 4443 public List<OptionContext> option() { 4444 return getRuleContexts(OptionContext.class); 4445 } 4446 public OptionContext option(int i) { 4447 return getRuleContext(OptionContext.class,i); 4448 } 4449 public List<TbodyContext> tbody() { 4450 return getRuleContexts(TbodyContext.class); 4451 } 4452 public TbodyContext tbody(int i) { 4453 return getRuleContext(TbodyContext.class,i); 4454 } 4455 public List<TheadContext> thead() { 4456 return getRuleContexts(TheadContext.class); 4457 } 4458 public TheadContext thead(int i) { 4459 return getRuleContext(TheadContext.class,i); 4460 } 4461 public List<TfootContext> tfoot() { 4462 return getRuleContexts(TfootContext.class); 4463 } 4464 public TfootContext tfoot(int i) { 4465 return getRuleContext(TfootContext.class,i); 4466 } 4467 public List<PTagOpenContext> pTagOpen() { 4468 return getRuleContexts(PTagOpenContext.class); 4469 } 4470 public PTagOpenContext pTagOpen(int i) { 4471 return getRuleContext(PTagOpenContext.class,i); 4472 } 4473 public List<LiTagOpenContext> liTagOpen() { 4474 return getRuleContexts(LiTagOpenContext.class); 4475 } 4476 public LiTagOpenContext liTagOpen(int i) { 4477 return getRuleContext(LiTagOpenContext.class,i); 4478 } 4479 public List<TrTagOpenContext> trTagOpen() { 4480 return getRuleContexts(TrTagOpenContext.class); 4481 } 4482 public TrTagOpenContext trTagOpen(int i) { 4483 return getRuleContext(TrTagOpenContext.class,i); 4484 } 4485 public List<TdTagOpenContext> tdTagOpen() { 4486 return getRuleContexts(TdTagOpenContext.class); 4487 } 4488 public TdTagOpenContext tdTagOpen(int i) { 4489 return getRuleContext(TdTagOpenContext.class,i); 4490 } 4491 public List<BodyTagOpenContext> bodyTagOpen() { 4492 return getRuleContexts(BodyTagOpenContext.class); 4493 } 4494 public BodyTagOpenContext bodyTagOpen(int i) { 4495 return getRuleContext(BodyTagOpenContext.class,i); 4496 } 4497 public List<ColgroupTagOpenContext> colgroupTagOpen() { 4498 return getRuleContexts(ColgroupTagOpenContext.class); 4499 } 4500 public ColgroupTagOpenContext colgroupTagOpen(int i) { 4501 return getRuleContext(ColgroupTagOpenContext.class,i); 4502 } 4503 public List<DdTagOpenContext> ddTagOpen() { 4504 return getRuleContexts(DdTagOpenContext.class); 4505 } 4506 public DdTagOpenContext ddTagOpen(int i) { 4507 return getRuleContext(DdTagOpenContext.class,i); 4508 } 4509 public List<DtTagOpenContext> dtTagOpen() { 4510 return getRuleContexts(DtTagOpenContext.class); 4511 } 4512 public DtTagOpenContext dtTagOpen(int i) { 4513 return getRuleContext(DtTagOpenContext.class,i); 4514 } 4515 public List<HeadTagOpenContext> headTagOpen() { 4516 return getRuleContexts(HeadTagOpenContext.class); 4517 } 4518 public HeadTagOpenContext headTagOpen(int i) { 4519 return getRuleContext(HeadTagOpenContext.class,i); 4520 } 4521 public List<HtmlTagOpenContext> htmlTagOpen() { 4522 return getRuleContexts(HtmlTagOpenContext.class); 4523 } 4524 public HtmlTagOpenContext htmlTagOpen(int i) { 4525 return getRuleContext(HtmlTagOpenContext.class,i); 4526 } 4527 public List<OptionTagOpenContext> optionTagOpen() { 4528 return getRuleContexts(OptionTagOpenContext.class); 4529 } 4530 public OptionTagOpenContext optionTagOpen(int i) { 4531 return getRuleContext(OptionTagOpenContext.class,i); 4532 } 4533 public List<TbodyTagOpenContext> tbodyTagOpen() { 4534 return getRuleContexts(TbodyTagOpenContext.class); 4535 } 4536 public TbodyTagOpenContext tbodyTagOpen(int i) { 4537 return getRuleContext(TbodyTagOpenContext.class,i); 4538 } 4539 public List<TheadTagOpenContext> theadTagOpen() { 4540 return getRuleContexts(TheadTagOpenContext.class); 4541 } 4542 public TheadTagOpenContext theadTagOpen(int i) { 4543 return getRuleContext(TheadTagOpenContext.class,i); 4544 } 4545 public List<TfootTagOpenContext> tfootTagOpen() { 4546 return getRuleContexts(TfootTagOpenContext.class); 4547 } 4548 public TfootTagOpenContext tfootTagOpen(int i) { 4549 return getRuleContext(TfootTagOpenContext.class,i); 4550 } 4551 public List<HtmlCommentContext> htmlComment() { 4552 return getRuleContexts(HtmlCommentContext.class); 4553 } 4554 public HtmlCommentContext htmlComment(int i) { 4555 return getRuleContext(HtmlCommentContext.class,i); 4556 } 4557 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 4558 public TerminalNode CDATA(int i) { 4559 return getToken(JavadocParser.CDATA, i); 4560 } 4561 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4562 public TerminalNode NEWLINE(int i) { 4563 return getToken(JavadocParser.NEWLINE, i); 4564 } 4565 public List<TextContext> text() { 4566 return getRuleContexts(TextContext.class); 4567 } 4568 public TextContext text(int i) { 4569 return getRuleContext(TextContext.class,i); 4570 } 4571 public List<JavadocInlineTagContext> javadocInlineTag() { 4572 return getRuleContexts(JavadocInlineTagContext.class); 4573 } 4574 public JavadocInlineTagContext javadocInlineTag(int i) { 4575 return getRuleContext(JavadocInlineTagContext.class,i); 4576 } 4577 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4578 public TerminalNode LEADING_ASTERISK(int i) { 4579 return getToken(JavadocParser.LEADING_ASTERISK, i); 4580 } 4581 public ThContext(ParserRuleContext parent, int invokingState) { 4582 super(parent, invokingState); 4583 } 4584 @Override public int getRuleIndex() { return RULE_th; } 4585 @Override 4586 public void enterRule(ParseTreeListener listener) { 4587 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTh(this); 4588 } 4589 @Override 4590 public void exitRule(ParseTreeListener listener) { 4591 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTh(this); 4592 } 4593 @Override 4594 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4595 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTh(this); 4596 else return visitor.visitChildren(this); 4597 } 4598 } 4599 4600 public final ThContext th() throws RecognitionException { 4601 ThContext _localctx = new ThContext(_ctx, getState()); 4602 enterRule(_localctx, 40, RULE_th); 4603 try { 4604 int _alt; 4605 enterOuterAlt(_localctx, 1); 4606 { 4607 setState(606); 4608 thTagOpen(); 4609 setState(646); 4610 _errHandler.sync(this); 4611 _alt = getInterpreter().adaptivePredict(_input,41,_ctx); 4612 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 4613 if ( _alt==1 ) { 4614 { 4615 setState(644); 4616 _errHandler.sync(this); 4617 switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { 4618 case 1: 4619 { 4620 setState(607); 4621 htmlTag(); 4622 } 4623 break; 4624 case 2: 4625 { 4626 setState(608); 4627 singletonTag(); 4628 } 4629 break; 4630 case 3: 4631 { 4632 setState(609); 4633 paragraph(); 4634 } 4635 break; 4636 case 4: 4637 { 4638 setState(610); 4639 li(); 4640 } 4641 break; 4642 case 5: 4643 { 4644 setState(611); 4645 tr(); 4646 } 4647 break; 4648 case 6: 4649 { 4650 setState(612); 4651 td(); 4652 } 4653 break; 4654 case 7: 4655 { 4656 setState(613); 4657 body(); 4658 } 4659 break; 4660 case 8: 4661 { 4662 setState(614); 4663 colgroup(); 4664 } 4665 break; 4666 case 9: 4667 { 4668 setState(615); 4669 dd(); 4670 } 4671 break; 4672 case 10: 4673 { 4674 setState(616); 4675 dt(); 4676 } 4677 break; 4678 case 11: 4679 { 4680 setState(617); 4681 head(); 4682 } 4683 break; 4684 case 12: 4685 { 4686 setState(618); 4687 html(); 4688 } 4689 break; 4690 case 13: 4691 { 4692 setState(619); 4693 option(); 4694 } 4695 break; 4696 case 14: 4697 { 4698 setState(620); 4699 tbody(); 4700 } 4701 break; 4702 case 15: 4703 { 4704 setState(621); 4705 thead(); 4706 } 4707 break; 4708 case 16: 4709 { 4710 setState(622); 4711 tfoot(); 4712 } 4713 break; 4714 case 17: 4715 { 4716 setState(623); 4717 pTagOpen(); 4718 } 4719 break; 4720 case 18: 4721 { 4722 setState(624); 4723 liTagOpen(); 4724 } 4725 break; 4726 case 19: 4727 { 4728 setState(625); 4729 trTagOpen(); 4730 } 4731 break; 4732 case 20: 4733 { 4734 setState(626); 4735 tdTagOpen(); 4736 } 4737 break; 4738 case 21: 4739 { 4740 setState(627); 4741 bodyTagOpen(); 4742 } 4743 break; 4744 case 22: 4745 { 4746 setState(628); 4747 colgroupTagOpen(); 4748 } 4749 break; 4750 case 23: 4751 { 4752 setState(629); 4753 ddTagOpen(); 4754 } 4755 break; 4756 case 24: 4757 { 4758 setState(630); 4759 dtTagOpen(); 4760 } 4761 break; 4762 case 25: 4763 { 4764 setState(631); 4765 headTagOpen(); 4766 } 4767 break; 4768 case 26: 4769 { 4770 setState(632); 4771 htmlTagOpen(); 4772 } 4773 break; 4774 case 27: 4775 { 4776 setState(633); 4777 optionTagOpen(); 4778 } 4779 break; 4780 case 28: 4781 { 4782 setState(634); 4783 tbodyTagOpen(); 4784 } 4785 break; 4786 case 29: 4787 { 4788 setState(635); 4789 theadTagOpen(); 4790 } 4791 break; 4792 case 30: 4793 { 4794 setState(636); 4795 tfootTagOpen(); 4796 } 4797 break; 4798 case 31: 4799 { 4800 { 4801 setState(637); 4802 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4803 setState(638); 4804 match(LEADING_ASTERISK); 4805 } 4806 } 4807 break; 4808 case 32: 4809 { 4810 setState(639); 4811 htmlComment(); 4812 } 4813 break; 4814 case 33: 4815 { 4816 setState(640); 4817 match(CDATA); 4818 } 4819 break; 4820 case 34: 4821 { 4822 setState(641); 4823 match(NEWLINE); 4824 } 4825 break; 4826 case 35: 4827 { 4828 setState(642); 4829 text(); 4830 } 4831 break; 4832 case 36: 4833 { 4834 setState(643); 4835 javadocInlineTag(); 4836 } 4837 break; 4838 } 4839 } 4840 } 4841 setState(648); 4842 _errHandler.sync(this); 4843 _alt = getInterpreter().adaptivePredict(_input,41,_ctx); 4844 } 4845 setState(649); 4846 thTagClose(); 4847 } 4848 } 4849 catch (RecognitionException re) { 4850 _localctx.exception = re; 4851 _errHandler.reportError(this, re); 4852 _errHandler.recover(this, re); 4853 } 4854 finally { 4855 exitRule(); 4856 } 4857 return _localctx; 4858 } 4859 4860 public static class BodyTagOpenContext extends ParserRuleContext { 4861 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4862 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 4863 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4864 public List<AttributeContext> attribute() { 4865 return getRuleContexts(AttributeContext.class); 4866 } 4867 public AttributeContext attribute(int i) { 4868 return getRuleContext(AttributeContext.class,i); 4869 } 4870 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4871 public TerminalNode NEWLINE(int i) { 4872 return getToken(JavadocParser.NEWLINE, i); 4873 } 4874 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4875 public TerminalNode LEADING_ASTERISK(int i) { 4876 return getToken(JavadocParser.LEADING_ASTERISK, i); 4877 } 4878 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4879 public TerminalNode WS(int i) { 4880 return getToken(JavadocParser.WS, i); 4881 } 4882 public BodyTagOpenContext(ParserRuleContext parent, int invokingState) { 4883 super(parent, invokingState); 4884 } 4885 @Override public int getRuleIndex() { return RULE_bodyTagOpen; } 4886 @Override 4887 public void enterRule(ParseTreeListener listener) { 4888 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagOpen(this); 4889 } 4890 @Override 4891 public void exitRule(ParseTreeListener listener) { 4892 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagOpen(this); 4893 } 4894 @Override 4895 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4896 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagOpen(this); 4897 else return visitor.visitChildren(this); 4898 } 4899 } 4900 4901 public final BodyTagOpenContext bodyTagOpen() throws RecognitionException { 4902 BodyTagOpenContext _localctx = new BodyTagOpenContext(_ctx, getState()); 4903 enterRule(_localctx, 42, RULE_bodyTagOpen); 4904 int _la; 4905 try { 4906 enterOuterAlt(_localctx, 1); 4907 { 4908 setState(651); 4909 match(OPEN); 4910 setState(652); 4911 match(BODY_HTML_TAG_NAME); 4912 setState(659); 4913 _errHandler.sync(this); 4914 _la = _input.LA(1); 4915 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4916 { 4917 setState(657); 4918 switch (_input.LA(1)) { 4919 case HTML_TAG_NAME: 4920 { 4921 setState(653); 4922 attribute(); 4923 } 4924 break; 4925 case NEWLINE: 4926 { 4927 setState(654); 4928 match(NEWLINE); 4929 } 4930 break; 4931 case LEADING_ASTERISK: 4932 { 4933 setState(655); 4934 match(LEADING_ASTERISK); 4935 } 4936 break; 4937 case WS: 4938 { 4939 setState(656); 4940 match(WS); 4941 } 4942 break; 4943 default: 4944 throw new NoViableAltException(this); 4945 } 4946 } 4947 setState(661); 4948 _errHandler.sync(this); 4949 _la = _input.LA(1); 4950 } 4951 setState(662); 4952 match(CLOSE); 4953 } 4954 } 4955 catch (RecognitionException re) { 4956 _localctx.exception = re; 4957 _errHandler.reportError(this, re); 4958 _errHandler.recover(this, re); 4959 } 4960 finally { 4961 exitRule(); 4962 } 4963 return _localctx; 4964 } 4965 4966 public static class BodyTagCloseContext extends ParserRuleContext { 4967 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4968 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4969 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 4970 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4971 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4972 public TerminalNode NEWLINE(int i) { 4973 return getToken(JavadocParser.NEWLINE, i); 4974 } 4975 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4976 public TerminalNode LEADING_ASTERISK(int i) { 4977 return getToken(JavadocParser.LEADING_ASTERISK, i); 4978 } 4979 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4980 public TerminalNode WS(int i) { 4981 return getToken(JavadocParser.WS, i); 4982 } 4983 public BodyTagCloseContext(ParserRuleContext parent, int invokingState) { 4984 super(parent, invokingState); 4985 } 4986 @Override public int getRuleIndex() { return RULE_bodyTagClose; } 4987 @Override 4988 public void enterRule(ParseTreeListener listener) { 4989 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagClose(this); 4990 } 4991 @Override 4992 public void exitRule(ParseTreeListener listener) { 4993 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagClose(this); 4994 } 4995 @Override 4996 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4997 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagClose(this); 4998 else return visitor.visitChildren(this); 4999 } 5000 } 5001 5002 public final BodyTagCloseContext bodyTagClose() throws RecognitionException { 5003 BodyTagCloseContext _localctx = new BodyTagCloseContext(_ctx, getState()); 5004 enterRule(_localctx, 44, RULE_bodyTagClose); 5005 int _la; 5006 try { 5007 enterOuterAlt(_localctx, 1); 5008 { 5009 setState(664); 5010 match(OPEN); 5011 setState(665); 5012 match(SLASH); 5013 setState(666); 5014 match(BODY_HTML_TAG_NAME); 5015 setState(670); 5016 _errHandler.sync(this); 5017 _la = _input.LA(1); 5018 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5019 { 5020 { 5021 setState(667); 5022 _la = _input.LA(1); 5023 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5024 _errHandler.recoverInline(this); 5025 } else { 5026 consume(); 5027 } 5028 } 5029 } 5030 setState(672); 5031 _errHandler.sync(this); 5032 _la = _input.LA(1); 5033 } 5034 setState(673); 5035 match(CLOSE); 5036 } 5037 } 5038 catch (RecognitionException re) { 5039 _localctx.exception = re; 5040 _errHandler.reportError(this, re); 5041 _errHandler.recover(this, re); 5042 } 5043 finally { 5044 exitRule(); 5045 } 5046 return _localctx; 5047 } 5048 5049 public static class BodyContext extends ParserRuleContext { 5050 public BodyTagOpenContext bodyTagOpen() { 5051 return getRuleContext(BodyTagOpenContext.class,0); 5052 } 5053 public BodyTagCloseContext bodyTagClose() { 5054 return getRuleContext(BodyTagCloseContext.class,0); 5055 } 5056 public List<HtmlTagContext> htmlTag() { 5057 return getRuleContexts(HtmlTagContext.class); 5058 } 5059 public HtmlTagContext htmlTag(int i) { 5060 return getRuleContext(HtmlTagContext.class,i); 5061 } 5062 public List<SingletonTagContext> singletonTag() { 5063 return getRuleContexts(SingletonTagContext.class); 5064 } 5065 public SingletonTagContext singletonTag(int i) { 5066 return getRuleContext(SingletonTagContext.class,i); 5067 } 5068 public List<ParagraphContext> paragraph() { 5069 return getRuleContexts(ParagraphContext.class); 5070 } 5071 public ParagraphContext paragraph(int i) { 5072 return getRuleContext(ParagraphContext.class,i); 5073 } 5074 public List<LiContext> li() { 5075 return getRuleContexts(LiContext.class); 5076 } 5077 public LiContext li(int i) { 5078 return getRuleContext(LiContext.class,i); 5079 } 5080 public List<TrContext> tr() { 5081 return getRuleContexts(TrContext.class); 5082 } 5083 public TrContext tr(int i) { 5084 return getRuleContext(TrContext.class,i); 5085 } 5086 public List<TdContext> td() { 5087 return getRuleContexts(TdContext.class); 5088 } 5089 public TdContext td(int i) { 5090 return getRuleContext(TdContext.class,i); 5091 } 5092 public List<ThContext> th() { 5093 return getRuleContexts(ThContext.class); 5094 } 5095 public ThContext th(int i) { 5096 return getRuleContext(ThContext.class,i); 5097 } 5098 public List<ColgroupContext> colgroup() { 5099 return getRuleContexts(ColgroupContext.class); 5100 } 5101 public ColgroupContext colgroup(int i) { 5102 return getRuleContext(ColgroupContext.class,i); 5103 } 5104 public List<DdContext> dd() { 5105 return getRuleContexts(DdContext.class); 5106 } 5107 public DdContext dd(int i) { 5108 return getRuleContext(DdContext.class,i); 5109 } 5110 public List<DtContext> dt() { 5111 return getRuleContexts(DtContext.class); 5112 } 5113 public DtContext dt(int i) { 5114 return getRuleContext(DtContext.class,i); 5115 } 5116 public List<HeadContext> head() { 5117 return getRuleContexts(HeadContext.class); 5118 } 5119 public HeadContext head(int i) { 5120 return getRuleContext(HeadContext.class,i); 5121 } 5122 public List<HtmlContext> html() { 5123 return getRuleContexts(HtmlContext.class); 5124 } 5125 public HtmlContext html(int i) { 5126 return getRuleContext(HtmlContext.class,i); 5127 } 5128 public List<OptionContext> option() { 5129 return getRuleContexts(OptionContext.class); 5130 } 5131 public OptionContext option(int i) { 5132 return getRuleContext(OptionContext.class,i); 5133 } 5134 public List<TbodyContext> tbody() { 5135 return getRuleContexts(TbodyContext.class); 5136 } 5137 public TbodyContext tbody(int i) { 5138 return getRuleContext(TbodyContext.class,i); 5139 } 5140 public List<TheadContext> thead() { 5141 return getRuleContexts(TheadContext.class); 5142 } 5143 public TheadContext thead(int i) { 5144 return getRuleContext(TheadContext.class,i); 5145 } 5146 public List<TfootContext> tfoot() { 5147 return getRuleContexts(TfootContext.class); 5148 } 5149 public TfootContext tfoot(int i) { 5150 return getRuleContext(TfootContext.class,i); 5151 } 5152 public List<PTagOpenContext> pTagOpen() { 5153 return getRuleContexts(PTagOpenContext.class); 5154 } 5155 public PTagOpenContext pTagOpen(int i) { 5156 return getRuleContext(PTagOpenContext.class,i); 5157 } 5158 public List<LiTagOpenContext> liTagOpen() { 5159 return getRuleContexts(LiTagOpenContext.class); 5160 } 5161 public LiTagOpenContext liTagOpen(int i) { 5162 return getRuleContext(LiTagOpenContext.class,i); 5163 } 5164 public List<TrTagOpenContext> trTagOpen() { 5165 return getRuleContexts(TrTagOpenContext.class); 5166 } 5167 public TrTagOpenContext trTagOpen(int i) { 5168 return getRuleContext(TrTagOpenContext.class,i); 5169 } 5170 public List<TdTagOpenContext> tdTagOpen() { 5171 return getRuleContexts(TdTagOpenContext.class); 5172 } 5173 public TdTagOpenContext tdTagOpen(int i) { 5174 return getRuleContext(TdTagOpenContext.class,i); 5175 } 5176 public List<ThTagOpenContext> thTagOpen() { 5177 return getRuleContexts(ThTagOpenContext.class); 5178 } 5179 public ThTagOpenContext thTagOpen(int i) { 5180 return getRuleContext(ThTagOpenContext.class,i); 5181 } 5182 public List<ColgroupTagOpenContext> colgroupTagOpen() { 5183 return getRuleContexts(ColgroupTagOpenContext.class); 5184 } 5185 public ColgroupTagOpenContext colgroupTagOpen(int i) { 5186 return getRuleContext(ColgroupTagOpenContext.class,i); 5187 } 5188 public List<DdTagOpenContext> ddTagOpen() { 5189 return getRuleContexts(DdTagOpenContext.class); 5190 } 5191 public DdTagOpenContext ddTagOpen(int i) { 5192 return getRuleContext(DdTagOpenContext.class,i); 5193 } 5194 public List<DtTagOpenContext> dtTagOpen() { 5195 return getRuleContexts(DtTagOpenContext.class); 5196 } 5197 public DtTagOpenContext dtTagOpen(int i) { 5198 return getRuleContext(DtTagOpenContext.class,i); 5199 } 5200 public List<HeadTagOpenContext> headTagOpen() { 5201 return getRuleContexts(HeadTagOpenContext.class); 5202 } 5203 public HeadTagOpenContext headTagOpen(int i) { 5204 return getRuleContext(HeadTagOpenContext.class,i); 5205 } 5206 public List<HtmlTagOpenContext> htmlTagOpen() { 5207 return getRuleContexts(HtmlTagOpenContext.class); 5208 } 5209 public HtmlTagOpenContext htmlTagOpen(int i) { 5210 return getRuleContext(HtmlTagOpenContext.class,i); 5211 } 5212 public List<OptionTagOpenContext> optionTagOpen() { 5213 return getRuleContexts(OptionTagOpenContext.class); 5214 } 5215 public OptionTagOpenContext optionTagOpen(int i) { 5216 return getRuleContext(OptionTagOpenContext.class,i); 5217 } 5218 public List<TbodyTagOpenContext> tbodyTagOpen() { 5219 return getRuleContexts(TbodyTagOpenContext.class); 5220 } 5221 public TbodyTagOpenContext tbodyTagOpen(int i) { 5222 return getRuleContext(TbodyTagOpenContext.class,i); 5223 } 5224 public List<TheadTagOpenContext> theadTagOpen() { 5225 return getRuleContexts(TheadTagOpenContext.class); 5226 } 5227 public TheadTagOpenContext theadTagOpen(int i) { 5228 return getRuleContext(TheadTagOpenContext.class,i); 5229 } 5230 public List<TfootTagOpenContext> tfootTagOpen() { 5231 return getRuleContexts(TfootTagOpenContext.class); 5232 } 5233 public TfootTagOpenContext tfootTagOpen(int i) { 5234 return getRuleContext(TfootTagOpenContext.class,i); 5235 } 5236 public List<HtmlCommentContext> htmlComment() { 5237 return getRuleContexts(HtmlCommentContext.class); 5238 } 5239 public HtmlCommentContext htmlComment(int i) { 5240 return getRuleContext(HtmlCommentContext.class,i); 5241 } 5242 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5243 public TerminalNode CDATA(int i) { 5244 return getToken(JavadocParser.CDATA, i); 5245 } 5246 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5247 public TerminalNode NEWLINE(int i) { 5248 return getToken(JavadocParser.NEWLINE, i); 5249 } 5250 public List<TextContext> text() { 5251 return getRuleContexts(TextContext.class); 5252 } 5253 public TextContext text(int i) { 5254 return getRuleContext(TextContext.class,i); 5255 } 5256 public List<JavadocInlineTagContext> javadocInlineTag() { 5257 return getRuleContexts(JavadocInlineTagContext.class); 5258 } 5259 public JavadocInlineTagContext javadocInlineTag(int i) { 5260 return getRuleContext(JavadocInlineTagContext.class,i); 5261 } 5262 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5263 public TerminalNode LEADING_ASTERISK(int i) { 5264 return getToken(JavadocParser.LEADING_ASTERISK, i); 5265 } 5266 public BodyContext(ParserRuleContext parent, int invokingState) { 5267 super(parent, invokingState); 5268 } 5269 @Override public int getRuleIndex() { return RULE_body; } 5270 @Override 5271 public void enterRule(ParseTreeListener listener) { 5272 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBody(this); 5273 } 5274 @Override 5275 public void exitRule(ParseTreeListener listener) { 5276 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBody(this); 5277 } 5278 @Override 5279 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5280 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBody(this); 5281 else return visitor.visitChildren(this); 5282 } 5283 } 5284 5285 public final BodyContext body() throws RecognitionException { 5286 BodyContext _localctx = new BodyContext(_ctx, getState()); 5287 enterRule(_localctx, 46, RULE_body); 5288 try { 5289 int _alt; 5290 enterOuterAlt(_localctx, 1); 5291 { 5292 setState(675); 5293 bodyTagOpen(); 5294 setState(715); 5295 _errHandler.sync(this); 5296 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5297 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5298 if ( _alt==1 ) { 5299 { 5300 setState(713); 5301 _errHandler.sync(this); 5302 switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { 5303 case 1: 5304 { 5305 setState(676); 5306 htmlTag(); 5307 } 5308 break; 5309 case 2: 5310 { 5311 setState(677); 5312 singletonTag(); 5313 } 5314 break; 5315 case 3: 5316 { 5317 setState(678); 5318 paragraph(); 5319 } 5320 break; 5321 case 4: 5322 { 5323 setState(679); 5324 li(); 5325 } 5326 break; 5327 case 5: 5328 { 5329 setState(680); 5330 tr(); 5331 } 5332 break; 5333 case 6: 5334 { 5335 setState(681); 5336 td(); 5337 } 5338 break; 5339 case 7: 5340 { 5341 setState(682); 5342 th(); 5343 } 5344 break; 5345 case 8: 5346 { 5347 setState(683); 5348 colgroup(); 5349 } 5350 break; 5351 case 9: 5352 { 5353 setState(684); 5354 dd(); 5355 } 5356 break; 5357 case 10: 5358 { 5359 setState(685); 5360 dt(); 5361 } 5362 break; 5363 case 11: 5364 { 5365 setState(686); 5366 head(); 5367 } 5368 break; 5369 case 12: 5370 { 5371 setState(687); 5372 html(); 5373 } 5374 break; 5375 case 13: 5376 { 5377 setState(688); 5378 option(); 5379 } 5380 break; 5381 case 14: 5382 { 5383 setState(689); 5384 tbody(); 5385 } 5386 break; 5387 case 15: 5388 { 5389 setState(690); 5390 thead(); 5391 } 5392 break; 5393 case 16: 5394 { 5395 setState(691); 5396 tfoot(); 5397 } 5398 break; 5399 case 17: 5400 { 5401 setState(692); 5402 pTagOpen(); 5403 } 5404 break; 5405 case 18: 5406 { 5407 setState(693); 5408 liTagOpen(); 5409 } 5410 break; 5411 case 19: 5412 { 5413 setState(694); 5414 trTagOpen(); 5415 } 5416 break; 5417 case 20: 5418 { 5419 setState(695); 5420 tdTagOpen(); 5421 } 5422 break; 5423 case 21: 5424 { 5425 setState(696); 5426 thTagOpen(); 5427 } 5428 break; 5429 case 22: 5430 { 5431 setState(697); 5432 colgroupTagOpen(); 5433 } 5434 break; 5435 case 23: 5436 { 5437 setState(698); 5438 ddTagOpen(); 5439 } 5440 break; 5441 case 24: 5442 { 5443 setState(699); 5444 dtTagOpen(); 5445 } 5446 break; 5447 case 25: 5448 { 5449 setState(700); 5450 headTagOpen(); 5451 } 5452 break; 5453 case 26: 5454 { 5455 setState(701); 5456 htmlTagOpen(); 5457 } 5458 break; 5459 case 27: 5460 { 5461 setState(702); 5462 optionTagOpen(); 5463 } 5464 break; 5465 case 28: 5466 { 5467 setState(703); 5468 tbodyTagOpen(); 5469 } 5470 break; 5471 case 29: 5472 { 5473 setState(704); 5474 theadTagOpen(); 5475 } 5476 break; 5477 case 30: 5478 { 5479 setState(705); 5480 tfootTagOpen(); 5481 } 5482 break; 5483 case 31: 5484 { 5485 { 5486 setState(706); 5487 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 5488 setState(707); 5489 match(LEADING_ASTERISK); 5490 } 5491 } 5492 break; 5493 case 32: 5494 { 5495 setState(708); 5496 htmlComment(); 5497 } 5498 break; 5499 case 33: 5500 { 5501 setState(709); 5502 match(CDATA); 5503 } 5504 break; 5505 case 34: 5506 { 5507 setState(710); 5508 match(NEWLINE); 5509 } 5510 break; 5511 case 35: 5512 { 5513 setState(711); 5514 text(); 5515 } 5516 break; 5517 case 36: 5518 { 5519 setState(712); 5520 javadocInlineTag(); 5521 } 5522 break; 5523 } 5524 } 5525 } 5526 setState(717); 5527 _errHandler.sync(this); 5528 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5529 } 5530 setState(718); 5531 bodyTagClose(); 5532 } 5533 } 5534 catch (RecognitionException re) { 5535 _localctx.exception = re; 5536 _errHandler.reportError(this, re); 5537 _errHandler.recover(this, re); 5538 } 5539 finally { 5540 exitRule(); 5541 } 5542 return _localctx; 5543 } 5544 5545 public static class ColgroupTagOpenContext extends ParserRuleContext { 5546 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5547 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5548 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5549 public List<AttributeContext> attribute() { 5550 return getRuleContexts(AttributeContext.class); 5551 } 5552 public AttributeContext attribute(int i) { 5553 return getRuleContext(AttributeContext.class,i); 5554 } 5555 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5556 public TerminalNode NEWLINE(int i) { 5557 return getToken(JavadocParser.NEWLINE, i); 5558 } 5559 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5560 public TerminalNode LEADING_ASTERISK(int i) { 5561 return getToken(JavadocParser.LEADING_ASTERISK, i); 5562 } 5563 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5564 public TerminalNode WS(int i) { 5565 return getToken(JavadocParser.WS, i); 5566 } 5567 public ColgroupTagOpenContext(ParserRuleContext parent, int invokingState) { 5568 super(parent, invokingState); 5569 } 5570 @Override public int getRuleIndex() { return RULE_colgroupTagOpen; } 5571 @Override 5572 public void enterRule(ParseTreeListener listener) { 5573 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagOpen(this); 5574 } 5575 @Override 5576 public void exitRule(ParseTreeListener listener) { 5577 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagOpen(this); 5578 } 5579 @Override 5580 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5581 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagOpen(this); 5582 else return visitor.visitChildren(this); 5583 } 5584 } 5585 5586 public final ColgroupTagOpenContext colgroupTagOpen() throws RecognitionException { 5587 ColgroupTagOpenContext _localctx = new ColgroupTagOpenContext(_ctx, getState()); 5588 enterRule(_localctx, 48, RULE_colgroupTagOpen); 5589 int _la; 5590 try { 5591 enterOuterAlt(_localctx, 1); 5592 { 5593 setState(720); 5594 match(OPEN); 5595 setState(721); 5596 match(COLGROUP_HTML_TAG_NAME); 5597 setState(728); 5598 _errHandler.sync(this); 5599 _la = _input.LA(1); 5600 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 5601 { 5602 setState(726); 5603 switch (_input.LA(1)) { 5604 case HTML_TAG_NAME: 5605 { 5606 setState(722); 5607 attribute(); 5608 } 5609 break; 5610 case NEWLINE: 5611 { 5612 setState(723); 5613 match(NEWLINE); 5614 } 5615 break; 5616 case LEADING_ASTERISK: 5617 { 5618 setState(724); 5619 match(LEADING_ASTERISK); 5620 } 5621 break; 5622 case WS: 5623 { 5624 setState(725); 5625 match(WS); 5626 } 5627 break; 5628 default: 5629 throw new NoViableAltException(this); 5630 } 5631 } 5632 setState(730); 5633 _errHandler.sync(this); 5634 _la = _input.LA(1); 5635 } 5636 setState(731); 5637 match(CLOSE); 5638 } 5639 } 5640 catch (RecognitionException re) { 5641 _localctx.exception = re; 5642 _errHandler.reportError(this, re); 5643 _errHandler.recover(this, re); 5644 } 5645 finally { 5646 exitRule(); 5647 } 5648 return _localctx; 5649 } 5650 5651 public static class ColgroupTagCloseContext extends ParserRuleContext { 5652 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5653 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 5654 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5655 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5656 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5657 public TerminalNode NEWLINE(int i) { 5658 return getToken(JavadocParser.NEWLINE, i); 5659 } 5660 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5661 public TerminalNode LEADING_ASTERISK(int i) { 5662 return getToken(JavadocParser.LEADING_ASTERISK, i); 5663 } 5664 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5665 public TerminalNode WS(int i) { 5666 return getToken(JavadocParser.WS, i); 5667 } 5668 public ColgroupTagCloseContext(ParserRuleContext parent, int invokingState) { 5669 super(parent, invokingState); 5670 } 5671 @Override public int getRuleIndex() { return RULE_colgroupTagClose; } 5672 @Override 5673 public void enterRule(ParseTreeListener listener) { 5674 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagClose(this); 5675 } 5676 @Override 5677 public void exitRule(ParseTreeListener listener) { 5678 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagClose(this); 5679 } 5680 @Override 5681 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5682 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagClose(this); 5683 else return visitor.visitChildren(this); 5684 } 5685 } 5686 5687 public final ColgroupTagCloseContext colgroupTagClose() throws RecognitionException { 5688 ColgroupTagCloseContext _localctx = new ColgroupTagCloseContext(_ctx, getState()); 5689 enterRule(_localctx, 50, RULE_colgroupTagClose); 5690 int _la; 5691 try { 5692 enterOuterAlt(_localctx, 1); 5693 { 5694 setState(733); 5695 match(OPEN); 5696 setState(734); 5697 match(SLASH); 5698 setState(735); 5699 match(COLGROUP_HTML_TAG_NAME); 5700 setState(739); 5701 _errHandler.sync(this); 5702 _la = _input.LA(1); 5703 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5704 { 5705 { 5706 setState(736); 5707 _la = _input.LA(1); 5708 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5709 _errHandler.recoverInline(this); 5710 } else { 5711 consume(); 5712 } 5713 } 5714 } 5715 setState(741); 5716 _errHandler.sync(this); 5717 _la = _input.LA(1); 5718 } 5719 setState(742); 5720 match(CLOSE); 5721 } 5722 } 5723 catch (RecognitionException re) { 5724 _localctx.exception = re; 5725 _errHandler.reportError(this, re); 5726 _errHandler.recover(this, re); 5727 } 5728 finally { 5729 exitRule(); 5730 } 5731 return _localctx; 5732 } 5733 5734 public static class ColgroupContext extends ParserRuleContext { 5735 public ColgroupTagOpenContext colgroupTagOpen() { 5736 return getRuleContext(ColgroupTagOpenContext.class,0); 5737 } 5738 public ColgroupTagCloseContext colgroupTagClose() { 5739 return getRuleContext(ColgroupTagCloseContext.class,0); 5740 } 5741 public List<HtmlTagContext> htmlTag() { 5742 return getRuleContexts(HtmlTagContext.class); 5743 } 5744 public HtmlTagContext htmlTag(int i) { 5745 return getRuleContext(HtmlTagContext.class,i); 5746 } 5747 public List<SingletonTagContext> singletonTag() { 5748 return getRuleContexts(SingletonTagContext.class); 5749 } 5750 public SingletonTagContext singletonTag(int i) { 5751 return getRuleContext(SingletonTagContext.class,i); 5752 } 5753 public List<ParagraphContext> paragraph() { 5754 return getRuleContexts(ParagraphContext.class); 5755 } 5756 public ParagraphContext paragraph(int i) { 5757 return getRuleContext(ParagraphContext.class,i); 5758 } 5759 public List<LiContext> li() { 5760 return getRuleContexts(LiContext.class); 5761 } 5762 public LiContext li(int i) { 5763 return getRuleContext(LiContext.class,i); 5764 } 5765 public List<TrContext> tr() { 5766 return getRuleContexts(TrContext.class); 5767 } 5768 public TrContext tr(int i) { 5769 return getRuleContext(TrContext.class,i); 5770 } 5771 public List<TdContext> td() { 5772 return getRuleContexts(TdContext.class); 5773 } 5774 public TdContext td(int i) { 5775 return getRuleContext(TdContext.class,i); 5776 } 5777 public List<ThContext> th() { 5778 return getRuleContexts(ThContext.class); 5779 } 5780 public ThContext th(int i) { 5781 return getRuleContext(ThContext.class,i); 5782 } 5783 public List<BodyContext> body() { 5784 return getRuleContexts(BodyContext.class); 5785 } 5786 public BodyContext body(int i) { 5787 return getRuleContext(BodyContext.class,i); 5788 } 5789 public List<DdContext> dd() { 5790 return getRuleContexts(DdContext.class); 5791 } 5792 public DdContext dd(int i) { 5793 return getRuleContext(DdContext.class,i); 5794 } 5795 public List<DtContext> dt() { 5796 return getRuleContexts(DtContext.class); 5797 } 5798 public DtContext dt(int i) { 5799 return getRuleContext(DtContext.class,i); 5800 } 5801 public List<HeadContext> head() { 5802 return getRuleContexts(HeadContext.class); 5803 } 5804 public HeadContext head(int i) { 5805 return getRuleContext(HeadContext.class,i); 5806 } 5807 public List<HtmlContext> html() { 5808 return getRuleContexts(HtmlContext.class); 5809 } 5810 public HtmlContext html(int i) { 5811 return getRuleContext(HtmlContext.class,i); 5812 } 5813 public List<OptionContext> option() { 5814 return getRuleContexts(OptionContext.class); 5815 } 5816 public OptionContext option(int i) { 5817 return getRuleContext(OptionContext.class,i); 5818 } 5819 public List<TbodyContext> tbody() { 5820 return getRuleContexts(TbodyContext.class); 5821 } 5822 public TbodyContext tbody(int i) { 5823 return getRuleContext(TbodyContext.class,i); 5824 } 5825 public List<TheadContext> thead() { 5826 return getRuleContexts(TheadContext.class); 5827 } 5828 public TheadContext thead(int i) { 5829 return getRuleContext(TheadContext.class,i); 5830 } 5831 public List<TfootContext> tfoot() { 5832 return getRuleContexts(TfootContext.class); 5833 } 5834 public TfootContext tfoot(int i) { 5835 return getRuleContext(TfootContext.class,i); 5836 } 5837 public List<PTagOpenContext> pTagOpen() { 5838 return getRuleContexts(PTagOpenContext.class); 5839 } 5840 public PTagOpenContext pTagOpen(int i) { 5841 return getRuleContext(PTagOpenContext.class,i); 5842 } 5843 public List<LiTagOpenContext> liTagOpen() { 5844 return getRuleContexts(LiTagOpenContext.class); 5845 } 5846 public LiTagOpenContext liTagOpen(int i) { 5847 return getRuleContext(LiTagOpenContext.class,i); 5848 } 5849 public List<TrTagOpenContext> trTagOpen() { 5850 return getRuleContexts(TrTagOpenContext.class); 5851 } 5852 public TrTagOpenContext trTagOpen(int i) { 5853 return getRuleContext(TrTagOpenContext.class,i); 5854 } 5855 public List<TdTagOpenContext> tdTagOpen() { 5856 return getRuleContexts(TdTagOpenContext.class); 5857 } 5858 public TdTagOpenContext tdTagOpen(int i) { 5859 return getRuleContext(TdTagOpenContext.class,i); 5860 } 5861 public List<ThTagOpenContext> thTagOpen() { 5862 return getRuleContexts(ThTagOpenContext.class); 5863 } 5864 public ThTagOpenContext thTagOpen(int i) { 5865 return getRuleContext(ThTagOpenContext.class,i); 5866 } 5867 public List<BodyTagOpenContext> bodyTagOpen() { 5868 return getRuleContexts(BodyTagOpenContext.class); 5869 } 5870 public BodyTagOpenContext bodyTagOpen(int i) { 5871 return getRuleContext(BodyTagOpenContext.class,i); 5872 } 5873 public List<DdTagOpenContext> ddTagOpen() { 5874 return getRuleContexts(DdTagOpenContext.class); 5875 } 5876 public DdTagOpenContext ddTagOpen(int i) { 5877 return getRuleContext(DdTagOpenContext.class,i); 5878 } 5879 public List<DtTagOpenContext> dtTagOpen() { 5880 return getRuleContexts(DtTagOpenContext.class); 5881 } 5882 public DtTagOpenContext dtTagOpen(int i) { 5883 return getRuleContext(DtTagOpenContext.class,i); 5884 } 5885 public List<HeadTagOpenContext> headTagOpen() { 5886 return getRuleContexts(HeadTagOpenContext.class); 5887 } 5888 public HeadTagOpenContext headTagOpen(int i) { 5889 return getRuleContext(HeadTagOpenContext.class,i); 5890 } 5891 public List<HtmlTagOpenContext> htmlTagOpen() { 5892 return getRuleContexts(HtmlTagOpenContext.class); 5893 } 5894 public HtmlTagOpenContext htmlTagOpen(int i) { 5895 return getRuleContext(HtmlTagOpenContext.class,i); 5896 } 5897 public List<OptionTagOpenContext> optionTagOpen() { 5898 return getRuleContexts(OptionTagOpenContext.class); 5899 } 5900 public OptionTagOpenContext optionTagOpen(int i) { 5901 return getRuleContext(OptionTagOpenContext.class,i); 5902 } 5903 public List<TbodyTagOpenContext> tbodyTagOpen() { 5904 return getRuleContexts(TbodyTagOpenContext.class); 5905 } 5906 public TbodyTagOpenContext tbodyTagOpen(int i) { 5907 return getRuleContext(TbodyTagOpenContext.class,i); 5908 } 5909 public List<TheadTagOpenContext> theadTagOpen() { 5910 return getRuleContexts(TheadTagOpenContext.class); 5911 } 5912 public TheadTagOpenContext theadTagOpen(int i) { 5913 return getRuleContext(TheadTagOpenContext.class,i); 5914 } 5915 public List<TfootTagOpenContext> tfootTagOpen() { 5916 return getRuleContexts(TfootTagOpenContext.class); 5917 } 5918 public TfootTagOpenContext tfootTagOpen(int i) { 5919 return getRuleContext(TfootTagOpenContext.class,i); 5920 } 5921 public List<HtmlCommentContext> htmlComment() { 5922 return getRuleContexts(HtmlCommentContext.class); 5923 } 5924 public HtmlCommentContext htmlComment(int i) { 5925 return getRuleContext(HtmlCommentContext.class,i); 5926 } 5927 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5928 public TerminalNode CDATA(int i) { 5929 return getToken(JavadocParser.CDATA, i); 5930 } 5931 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5932 public TerminalNode NEWLINE(int i) { 5933 return getToken(JavadocParser.NEWLINE, i); 5934 } 5935 public List<TextContext> text() { 5936 return getRuleContexts(TextContext.class); 5937 } 5938 public TextContext text(int i) { 5939 return getRuleContext(TextContext.class,i); 5940 } 5941 public List<JavadocInlineTagContext> javadocInlineTag() { 5942 return getRuleContexts(JavadocInlineTagContext.class); 5943 } 5944 public JavadocInlineTagContext javadocInlineTag(int i) { 5945 return getRuleContext(JavadocInlineTagContext.class,i); 5946 } 5947 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5948 public TerminalNode LEADING_ASTERISK(int i) { 5949 return getToken(JavadocParser.LEADING_ASTERISK, i); 5950 } 5951 public ColgroupContext(ParserRuleContext parent, int invokingState) { 5952 super(parent, invokingState); 5953 } 5954 @Override public int getRuleIndex() { return RULE_colgroup; } 5955 @Override 5956 public void enterRule(ParseTreeListener listener) { 5957 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroup(this); 5958 } 5959 @Override 5960 public void exitRule(ParseTreeListener listener) { 5961 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroup(this); 5962 } 5963 @Override 5964 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5965 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroup(this); 5966 else return visitor.visitChildren(this); 5967 } 5968 } 5969 5970 public final ColgroupContext colgroup() throws RecognitionException { 5971 ColgroupContext _localctx = new ColgroupContext(_ctx, getState()); 5972 enterRule(_localctx, 52, RULE_colgroup); 5973 try { 5974 int _alt; 5975 enterOuterAlt(_localctx, 1); 5976 { 5977 setState(744); 5978 colgroupTagOpen(); 5979 setState(784); 5980 _errHandler.sync(this); 5981 _alt = getInterpreter().adaptivePredict(_input,51,_ctx); 5982 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5983 if ( _alt==1 ) { 5984 { 5985 setState(782); 5986 _errHandler.sync(this); 5987 switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { 5988 case 1: 5989 { 5990 setState(745); 5991 htmlTag(); 5992 } 5993 break; 5994 case 2: 5995 { 5996 setState(746); 5997 singletonTag(); 5998 } 5999 break; 6000 case 3: 6001 { 6002 setState(747); 6003 paragraph(); 6004 } 6005 break; 6006 case 4: 6007 { 6008 setState(748); 6009 li(); 6010 } 6011 break; 6012 case 5: 6013 { 6014 setState(749); 6015 tr(); 6016 } 6017 break; 6018 case 6: 6019 { 6020 setState(750); 6021 td(); 6022 } 6023 break; 6024 case 7: 6025 { 6026 setState(751); 6027 th(); 6028 } 6029 break; 6030 case 8: 6031 { 6032 setState(752); 6033 body(); 6034 } 6035 break; 6036 case 9: 6037 { 6038 setState(753); 6039 dd(); 6040 } 6041 break; 6042 case 10: 6043 { 6044 setState(754); 6045 dt(); 6046 } 6047 break; 6048 case 11: 6049 { 6050 setState(755); 6051 head(); 6052 } 6053 break; 6054 case 12: 6055 { 6056 setState(756); 6057 html(); 6058 } 6059 break; 6060 case 13: 6061 { 6062 setState(757); 6063 option(); 6064 } 6065 break; 6066 case 14: 6067 { 6068 setState(758); 6069 tbody(); 6070 } 6071 break; 6072 case 15: 6073 { 6074 setState(759); 6075 thead(); 6076 } 6077 break; 6078 case 16: 6079 { 6080 setState(760); 6081 tfoot(); 6082 } 6083 break; 6084 case 17: 6085 { 6086 setState(761); 6087 pTagOpen(); 6088 } 6089 break; 6090 case 18: 6091 { 6092 setState(762); 6093 liTagOpen(); 6094 } 6095 break; 6096 case 19: 6097 { 6098 setState(763); 6099 trTagOpen(); 6100 } 6101 break; 6102 case 20: 6103 { 6104 setState(764); 6105 tdTagOpen(); 6106 } 6107 break; 6108 case 21: 6109 { 6110 setState(765); 6111 thTagOpen(); 6112 } 6113 break; 6114 case 22: 6115 { 6116 setState(766); 6117 bodyTagOpen(); 6118 } 6119 break; 6120 case 23: 6121 { 6122 setState(767); 6123 ddTagOpen(); 6124 } 6125 break; 6126 case 24: 6127 { 6128 setState(768); 6129 dtTagOpen(); 6130 } 6131 break; 6132 case 25: 6133 { 6134 setState(769); 6135 headTagOpen(); 6136 } 6137 break; 6138 case 26: 6139 { 6140 setState(770); 6141 htmlTagOpen(); 6142 } 6143 break; 6144 case 27: 6145 { 6146 setState(771); 6147 optionTagOpen(); 6148 } 6149 break; 6150 case 28: 6151 { 6152 setState(772); 6153 tbodyTagOpen(); 6154 } 6155 break; 6156 case 29: 6157 { 6158 setState(773); 6159 theadTagOpen(); 6160 } 6161 break; 6162 case 30: 6163 { 6164 setState(774); 6165 tfootTagOpen(); 6166 } 6167 break; 6168 case 31: 6169 { 6170 { 6171 setState(775); 6172 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6173 setState(776); 6174 match(LEADING_ASTERISK); 6175 } 6176 } 6177 break; 6178 case 32: 6179 { 6180 setState(777); 6181 htmlComment(); 6182 } 6183 break; 6184 case 33: 6185 { 6186 setState(778); 6187 match(CDATA); 6188 } 6189 break; 6190 case 34: 6191 { 6192 setState(779); 6193 match(NEWLINE); 6194 } 6195 break; 6196 case 35: 6197 { 6198 setState(780); 6199 text(); 6200 } 6201 break; 6202 case 36: 6203 { 6204 setState(781); 6205 javadocInlineTag(); 6206 } 6207 break; 6208 } 6209 } 6210 } 6211 setState(786); 6212 _errHandler.sync(this); 6213 _alt = getInterpreter().adaptivePredict(_input,51,_ctx); 6214 } 6215 setState(787); 6216 colgroupTagClose(); 6217 } 6218 } 6219 catch (RecognitionException re) { 6220 _localctx.exception = re; 6221 _errHandler.reportError(this, re); 6222 _errHandler.recover(this, re); 6223 } 6224 finally { 6225 exitRule(); 6226 } 6227 return _localctx; 6228 } 6229 6230 public static class DdTagOpenContext extends ParserRuleContext { 6231 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6232 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6233 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6234 public List<AttributeContext> attribute() { 6235 return getRuleContexts(AttributeContext.class); 6236 } 6237 public AttributeContext attribute(int i) { 6238 return getRuleContext(AttributeContext.class,i); 6239 } 6240 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6241 public TerminalNode NEWLINE(int i) { 6242 return getToken(JavadocParser.NEWLINE, i); 6243 } 6244 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6245 public TerminalNode LEADING_ASTERISK(int i) { 6246 return getToken(JavadocParser.LEADING_ASTERISK, i); 6247 } 6248 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6249 public TerminalNode WS(int i) { 6250 return getToken(JavadocParser.WS, i); 6251 } 6252 public DdTagOpenContext(ParserRuleContext parent, int invokingState) { 6253 super(parent, invokingState); 6254 } 6255 @Override public int getRuleIndex() { return RULE_ddTagOpen; } 6256 @Override 6257 public void enterRule(ParseTreeListener listener) { 6258 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagOpen(this); 6259 } 6260 @Override 6261 public void exitRule(ParseTreeListener listener) { 6262 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagOpen(this); 6263 } 6264 @Override 6265 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6266 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagOpen(this); 6267 else return visitor.visitChildren(this); 6268 } 6269 } 6270 6271 public final DdTagOpenContext ddTagOpen() throws RecognitionException { 6272 DdTagOpenContext _localctx = new DdTagOpenContext(_ctx, getState()); 6273 enterRule(_localctx, 54, RULE_ddTagOpen); 6274 int _la; 6275 try { 6276 enterOuterAlt(_localctx, 1); 6277 { 6278 setState(789); 6279 match(OPEN); 6280 setState(790); 6281 match(DD_HTML_TAG_NAME); 6282 setState(797); 6283 _errHandler.sync(this); 6284 _la = _input.LA(1); 6285 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6286 { 6287 setState(795); 6288 switch (_input.LA(1)) { 6289 case HTML_TAG_NAME: 6290 { 6291 setState(791); 6292 attribute(); 6293 } 6294 break; 6295 case NEWLINE: 6296 { 6297 setState(792); 6298 match(NEWLINE); 6299 } 6300 break; 6301 case LEADING_ASTERISK: 6302 { 6303 setState(793); 6304 match(LEADING_ASTERISK); 6305 } 6306 break; 6307 case WS: 6308 { 6309 setState(794); 6310 match(WS); 6311 } 6312 break; 6313 default: 6314 throw new NoViableAltException(this); 6315 } 6316 } 6317 setState(799); 6318 _errHandler.sync(this); 6319 _la = _input.LA(1); 6320 } 6321 setState(800); 6322 match(CLOSE); 6323 } 6324 } 6325 catch (RecognitionException re) { 6326 _localctx.exception = re; 6327 _errHandler.reportError(this, re); 6328 _errHandler.recover(this, re); 6329 } 6330 finally { 6331 exitRule(); 6332 } 6333 return _localctx; 6334 } 6335 6336 public static class DdTagCloseContext extends ParserRuleContext { 6337 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6338 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 6339 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6340 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6341 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6342 public TerminalNode NEWLINE(int i) { 6343 return getToken(JavadocParser.NEWLINE, i); 6344 } 6345 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6346 public TerminalNode LEADING_ASTERISK(int i) { 6347 return getToken(JavadocParser.LEADING_ASTERISK, i); 6348 } 6349 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6350 public TerminalNode WS(int i) { 6351 return getToken(JavadocParser.WS, i); 6352 } 6353 public DdTagCloseContext(ParserRuleContext parent, int invokingState) { 6354 super(parent, invokingState); 6355 } 6356 @Override public int getRuleIndex() { return RULE_ddTagClose; } 6357 @Override 6358 public void enterRule(ParseTreeListener listener) { 6359 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagClose(this); 6360 } 6361 @Override 6362 public void exitRule(ParseTreeListener listener) { 6363 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagClose(this); 6364 } 6365 @Override 6366 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6367 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagClose(this); 6368 else return visitor.visitChildren(this); 6369 } 6370 } 6371 6372 public final DdTagCloseContext ddTagClose() throws RecognitionException { 6373 DdTagCloseContext _localctx = new DdTagCloseContext(_ctx, getState()); 6374 enterRule(_localctx, 56, RULE_ddTagClose); 6375 int _la; 6376 try { 6377 enterOuterAlt(_localctx, 1); 6378 { 6379 setState(802); 6380 match(OPEN); 6381 setState(803); 6382 match(SLASH); 6383 setState(804); 6384 match(DD_HTML_TAG_NAME); 6385 setState(808); 6386 _errHandler.sync(this); 6387 _la = _input.LA(1); 6388 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 6389 { 6390 { 6391 setState(805); 6392 _la = _input.LA(1); 6393 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 6394 _errHandler.recoverInline(this); 6395 } else { 6396 consume(); 6397 } 6398 } 6399 } 6400 setState(810); 6401 _errHandler.sync(this); 6402 _la = _input.LA(1); 6403 } 6404 setState(811); 6405 match(CLOSE); 6406 } 6407 } 6408 catch (RecognitionException re) { 6409 _localctx.exception = re; 6410 _errHandler.reportError(this, re); 6411 _errHandler.recover(this, re); 6412 } 6413 finally { 6414 exitRule(); 6415 } 6416 return _localctx; 6417 } 6418 6419 public static class DdContext extends ParserRuleContext { 6420 public DdTagOpenContext ddTagOpen() { 6421 return getRuleContext(DdTagOpenContext.class,0); 6422 } 6423 public DdTagCloseContext ddTagClose() { 6424 return getRuleContext(DdTagCloseContext.class,0); 6425 } 6426 public List<HtmlTagContext> htmlTag() { 6427 return getRuleContexts(HtmlTagContext.class); 6428 } 6429 public HtmlTagContext htmlTag(int i) { 6430 return getRuleContext(HtmlTagContext.class,i); 6431 } 6432 public List<SingletonTagContext> singletonTag() { 6433 return getRuleContexts(SingletonTagContext.class); 6434 } 6435 public SingletonTagContext singletonTag(int i) { 6436 return getRuleContext(SingletonTagContext.class,i); 6437 } 6438 public List<ParagraphContext> paragraph() { 6439 return getRuleContexts(ParagraphContext.class); 6440 } 6441 public ParagraphContext paragraph(int i) { 6442 return getRuleContext(ParagraphContext.class,i); 6443 } 6444 public List<LiContext> li() { 6445 return getRuleContexts(LiContext.class); 6446 } 6447 public LiContext li(int i) { 6448 return getRuleContext(LiContext.class,i); 6449 } 6450 public List<TrContext> tr() { 6451 return getRuleContexts(TrContext.class); 6452 } 6453 public TrContext tr(int i) { 6454 return getRuleContext(TrContext.class,i); 6455 } 6456 public List<TdContext> td() { 6457 return getRuleContexts(TdContext.class); 6458 } 6459 public TdContext td(int i) { 6460 return getRuleContext(TdContext.class,i); 6461 } 6462 public List<ThContext> th() { 6463 return getRuleContexts(ThContext.class); 6464 } 6465 public ThContext th(int i) { 6466 return getRuleContext(ThContext.class,i); 6467 } 6468 public List<BodyContext> body() { 6469 return getRuleContexts(BodyContext.class); 6470 } 6471 public BodyContext body(int i) { 6472 return getRuleContext(BodyContext.class,i); 6473 } 6474 public List<ColgroupContext> colgroup() { 6475 return getRuleContexts(ColgroupContext.class); 6476 } 6477 public ColgroupContext colgroup(int i) { 6478 return getRuleContext(ColgroupContext.class,i); 6479 } 6480 public List<DtContext> dt() { 6481 return getRuleContexts(DtContext.class); 6482 } 6483 public DtContext dt(int i) { 6484 return getRuleContext(DtContext.class,i); 6485 } 6486 public List<HeadContext> head() { 6487 return getRuleContexts(HeadContext.class); 6488 } 6489 public HeadContext head(int i) { 6490 return getRuleContext(HeadContext.class,i); 6491 } 6492 public List<HtmlContext> html() { 6493 return getRuleContexts(HtmlContext.class); 6494 } 6495 public HtmlContext html(int i) { 6496 return getRuleContext(HtmlContext.class,i); 6497 } 6498 public List<OptionContext> option() { 6499 return getRuleContexts(OptionContext.class); 6500 } 6501 public OptionContext option(int i) { 6502 return getRuleContext(OptionContext.class,i); 6503 } 6504 public List<TbodyContext> tbody() { 6505 return getRuleContexts(TbodyContext.class); 6506 } 6507 public TbodyContext tbody(int i) { 6508 return getRuleContext(TbodyContext.class,i); 6509 } 6510 public List<TheadContext> thead() { 6511 return getRuleContexts(TheadContext.class); 6512 } 6513 public TheadContext thead(int i) { 6514 return getRuleContext(TheadContext.class,i); 6515 } 6516 public List<TfootContext> tfoot() { 6517 return getRuleContexts(TfootContext.class); 6518 } 6519 public TfootContext tfoot(int i) { 6520 return getRuleContext(TfootContext.class,i); 6521 } 6522 public List<PTagOpenContext> pTagOpen() { 6523 return getRuleContexts(PTagOpenContext.class); 6524 } 6525 public PTagOpenContext pTagOpen(int i) { 6526 return getRuleContext(PTagOpenContext.class,i); 6527 } 6528 public List<LiTagOpenContext> liTagOpen() { 6529 return getRuleContexts(LiTagOpenContext.class); 6530 } 6531 public LiTagOpenContext liTagOpen(int i) { 6532 return getRuleContext(LiTagOpenContext.class,i); 6533 } 6534 public List<TrTagOpenContext> trTagOpen() { 6535 return getRuleContexts(TrTagOpenContext.class); 6536 } 6537 public TrTagOpenContext trTagOpen(int i) { 6538 return getRuleContext(TrTagOpenContext.class,i); 6539 } 6540 public List<TdTagOpenContext> tdTagOpen() { 6541 return getRuleContexts(TdTagOpenContext.class); 6542 } 6543 public TdTagOpenContext tdTagOpen(int i) { 6544 return getRuleContext(TdTagOpenContext.class,i); 6545 } 6546 public List<ThTagOpenContext> thTagOpen() { 6547 return getRuleContexts(ThTagOpenContext.class); 6548 } 6549 public ThTagOpenContext thTagOpen(int i) { 6550 return getRuleContext(ThTagOpenContext.class,i); 6551 } 6552 public List<BodyTagOpenContext> bodyTagOpen() { 6553 return getRuleContexts(BodyTagOpenContext.class); 6554 } 6555 public BodyTagOpenContext bodyTagOpen(int i) { 6556 return getRuleContext(BodyTagOpenContext.class,i); 6557 } 6558 public List<ColgroupTagOpenContext> colgroupTagOpen() { 6559 return getRuleContexts(ColgroupTagOpenContext.class); 6560 } 6561 public ColgroupTagOpenContext colgroupTagOpen(int i) { 6562 return getRuleContext(ColgroupTagOpenContext.class,i); 6563 } 6564 public List<DtTagOpenContext> dtTagOpen() { 6565 return getRuleContexts(DtTagOpenContext.class); 6566 } 6567 public DtTagOpenContext dtTagOpen(int i) { 6568 return getRuleContext(DtTagOpenContext.class,i); 6569 } 6570 public List<HeadTagOpenContext> headTagOpen() { 6571 return getRuleContexts(HeadTagOpenContext.class); 6572 } 6573 public HeadTagOpenContext headTagOpen(int i) { 6574 return getRuleContext(HeadTagOpenContext.class,i); 6575 } 6576 public List<HtmlTagOpenContext> htmlTagOpen() { 6577 return getRuleContexts(HtmlTagOpenContext.class); 6578 } 6579 public HtmlTagOpenContext htmlTagOpen(int i) { 6580 return getRuleContext(HtmlTagOpenContext.class,i); 6581 } 6582 public List<OptionTagOpenContext> optionTagOpen() { 6583 return getRuleContexts(OptionTagOpenContext.class); 6584 } 6585 public OptionTagOpenContext optionTagOpen(int i) { 6586 return getRuleContext(OptionTagOpenContext.class,i); 6587 } 6588 public List<TbodyTagOpenContext> tbodyTagOpen() { 6589 return getRuleContexts(TbodyTagOpenContext.class); 6590 } 6591 public TbodyTagOpenContext tbodyTagOpen(int i) { 6592 return getRuleContext(TbodyTagOpenContext.class,i); 6593 } 6594 public List<TheadTagOpenContext> theadTagOpen() { 6595 return getRuleContexts(TheadTagOpenContext.class); 6596 } 6597 public TheadTagOpenContext theadTagOpen(int i) { 6598 return getRuleContext(TheadTagOpenContext.class,i); 6599 } 6600 public List<TfootTagOpenContext> tfootTagOpen() { 6601 return getRuleContexts(TfootTagOpenContext.class); 6602 } 6603 public TfootTagOpenContext tfootTagOpen(int i) { 6604 return getRuleContext(TfootTagOpenContext.class,i); 6605 } 6606 public List<HtmlCommentContext> htmlComment() { 6607 return getRuleContexts(HtmlCommentContext.class); 6608 } 6609 public HtmlCommentContext htmlComment(int i) { 6610 return getRuleContext(HtmlCommentContext.class,i); 6611 } 6612 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 6613 public TerminalNode CDATA(int i) { 6614 return getToken(JavadocParser.CDATA, i); 6615 } 6616 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6617 public TerminalNode NEWLINE(int i) { 6618 return getToken(JavadocParser.NEWLINE, i); 6619 } 6620 public List<TextContext> text() { 6621 return getRuleContexts(TextContext.class); 6622 } 6623 public TextContext text(int i) { 6624 return getRuleContext(TextContext.class,i); 6625 } 6626 public List<JavadocInlineTagContext> javadocInlineTag() { 6627 return getRuleContexts(JavadocInlineTagContext.class); 6628 } 6629 public JavadocInlineTagContext javadocInlineTag(int i) { 6630 return getRuleContext(JavadocInlineTagContext.class,i); 6631 } 6632 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6633 public TerminalNode LEADING_ASTERISK(int i) { 6634 return getToken(JavadocParser.LEADING_ASTERISK, i); 6635 } 6636 public DdContext(ParserRuleContext parent, int invokingState) { 6637 super(parent, invokingState); 6638 } 6639 @Override public int getRuleIndex() { return RULE_dd; } 6640 @Override 6641 public void enterRule(ParseTreeListener listener) { 6642 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDd(this); 6643 } 6644 @Override 6645 public void exitRule(ParseTreeListener listener) { 6646 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDd(this); 6647 } 6648 @Override 6649 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6650 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDd(this); 6651 else return visitor.visitChildren(this); 6652 } 6653 } 6654 6655 public final DdContext dd() throws RecognitionException { 6656 DdContext _localctx = new DdContext(_ctx, getState()); 6657 enterRule(_localctx, 58, RULE_dd); 6658 try { 6659 int _alt; 6660 enterOuterAlt(_localctx, 1); 6661 { 6662 setState(813); 6663 ddTagOpen(); 6664 setState(853); 6665 _errHandler.sync(this); 6666 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6667 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6668 if ( _alt==1 ) { 6669 { 6670 setState(851); 6671 _errHandler.sync(this); 6672 switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { 6673 case 1: 6674 { 6675 setState(814); 6676 htmlTag(); 6677 } 6678 break; 6679 case 2: 6680 { 6681 setState(815); 6682 singletonTag(); 6683 } 6684 break; 6685 case 3: 6686 { 6687 setState(816); 6688 paragraph(); 6689 } 6690 break; 6691 case 4: 6692 { 6693 setState(817); 6694 li(); 6695 } 6696 break; 6697 case 5: 6698 { 6699 setState(818); 6700 tr(); 6701 } 6702 break; 6703 case 6: 6704 { 6705 setState(819); 6706 td(); 6707 } 6708 break; 6709 case 7: 6710 { 6711 setState(820); 6712 th(); 6713 } 6714 break; 6715 case 8: 6716 { 6717 setState(821); 6718 body(); 6719 } 6720 break; 6721 case 9: 6722 { 6723 setState(822); 6724 colgroup(); 6725 } 6726 break; 6727 case 10: 6728 { 6729 setState(823); 6730 dt(); 6731 } 6732 break; 6733 case 11: 6734 { 6735 setState(824); 6736 head(); 6737 } 6738 break; 6739 case 12: 6740 { 6741 setState(825); 6742 html(); 6743 } 6744 break; 6745 case 13: 6746 { 6747 setState(826); 6748 option(); 6749 } 6750 break; 6751 case 14: 6752 { 6753 setState(827); 6754 tbody(); 6755 } 6756 break; 6757 case 15: 6758 { 6759 setState(828); 6760 thead(); 6761 } 6762 break; 6763 case 16: 6764 { 6765 setState(829); 6766 tfoot(); 6767 } 6768 break; 6769 case 17: 6770 { 6771 setState(830); 6772 pTagOpen(); 6773 } 6774 break; 6775 case 18: 6776 { 6777 setState(831); 6778 liTagOpen(); 6779 } 6780 break; 6781 case 19: 6782 { 6783 setState(832); 6784 trTagOpen(); 6785 } 6786 break; 6787 case 20: 6788 { 6789 setState(833); 6790 tdTagOpen(); 6791 } 6792 break; 6793 case 21: 6794 { 6795 setState(834); 6796 thTagOpen(); 6797 } 6798 break; 6799 case 22: 6800 { 6801 setState(835); 6802 bodyTagOpen(); 6803 } 6804 break; 6805 case 23: 6806 { 6807 setState(836); 6808 colgroupTagOpen(); 6809 } 6810 break; 6811 case 24: 6812 { 6813 setState(837); 6814 dtTagOpen(); 6815 } 6816 break; 6817 case 25: 6818 { 6819 setState(838); 6820 headTagOpen(); 6821 } 6822 break; 6823 case 26: 6824 { 6825 setState(839); 6826 htmlTagOpen(); 6827 } 6828 break; 6829 case 27: 6830 { 6831 setState(840); 6832 optionTagOpen(); 6833 } 6834 break; 6835 case 28: 6836 { 6837 setState(841); 6838 tbodyTagOpen(); 6839 } 6840 break; 6841 case 29: 6842 { 6843 setState(842); 6844 theadTagOpen(); 6845 } 6846 break; 6847 case 30: 6848 { 6849 setState(843); 6850 tfootTagOpen(); 6851 } 6852 break; 6853 case 31: 6854 { 6855 { 6856 setState(844); 6857 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6858 setState(845); 6859 match(LEADING_ASTERISK); 6860 } 6861 } 6862 break; 6863 case 32: 6864 { 6865 setState(846); 6866 htmlComment(); 6867 } 6868 break; 6869 case 33: 6870 { 6871 setState(847); 6872 match(CDATA); 6873 } 6874 break; 6875 case 34: 6876 { 6877 setState(848); 6878 match(NEWLINE); 6879 } 6880 break; 6881 case 35: 6882 { 6883 setState(849); 6884 text(); 6885 } 6886 break; 6887 case 36: 6888 { 6889 setState(850); 6890 javadocInlineTag(); 6891 } 6892 break; 6893 } 6894 } 6895 } 6896 setState(855); 6897 _errHandler.sync(this); 6898 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6899 } 6900 setState(856); 6901 ddTagClose(); 6902 } 6903 } 6904 catch (RecognitionException re) { 6905 _localctx.exception = re; 6906 _errHandler.reportError(this, re); 6907 _errHandler.recover(this, re); 6908 } 6909 finally { 6910 exitRule(); 6911 } 6912 return _localctx; 6913 } 6914 6915 public static class DtTagOpenContext extends ParserRuleContext { 6916 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6917 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 6918 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6919 public List<AttributeContext> attribute() { 6920 return getRuleContexts(AttributeContext.class); 6921 } 6922 public AttributeContext attribute(int i) { 6923 return getRuleContext(AttributeContext.class,i); 6924 } 6925 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6926 public TerminalNode NEWLINE(int i) { 6927 return getToken(JavadocParser.NEWLINE, i); 6928 } 6929 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6930 public TerminalNode LEADING_ASTERISK(int i) { 6931 return getToken(JavadocParser.LEADING_ASTERISK, i); 6932 } 6933 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6934 public TerminalNode WS(int i) { 6935 return getToken(JavadocParser.WS, i); 6936 } 6937 public DtTagOpenContext(ParserRuleContext parent, int invokingState) { 6938 super(parent, invokingState); 6939 } 6940 @Override public int getRuleIndex() { return RULE_dtTagOpen; } 6941 @Override 6942 public void enterRule(ParseTreeListener listener) { 6943 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagOpen(this); 6944 } 6945 @Override 6946 public void exitRule(ParseTreeListener listener) { 6947 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagOpen(this); 6948 } 6949 @Override 6950 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6951 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagOpen(this); 6952 else return visitor.visitChildren(this); 6953 } 6954 } 6955 6956 public final DtTagOpenContext dtTagOpen() throws RecognitionException { 6957 DtTagOpenContext _localctx = new DtTagOpenContext(_ctx, getState()); 6958 enterRule(_localctx, 60, RULE_dtTagOpen); 6959 int _la; 6960 try { 6961 enterOuterAlt(_localctx, 1); 6962 { 6963 setState(858); 6964 match(OPEN); 6965 setState(859); 6966 match(DT_HTML_TAG_NAME); 6967 setState(866); 6968 _errHandler.sync(this); 6969 _la = _input.LA(1); 6970 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6971 { 6972 setState(864); 6973 switch (_input.LA(1)) { 6974 case HTML_TAG_NAME: 6975 { 6976 setState(860); 6977 attribute(); 6978 } 6979 break; 6980 case NEWLINE: 6981 { 6982 setState(861); 6983 match(NEWLINE); 6984 } 6985 break; 6986 case LEADING_ASTERISK: 6987 { 6988 setState(862); 6989 match(LEADING_ASTERISK); 6990 } 6991 break; 6992 case WS: 6993 { 6994 setState(863); 6995 match(WS); 6996 } 6997 break; 6998 default: 6999 throw new NoViableAltException(this); 7000 } 7001 } 7002 setState(868); 7003 _errHandler.sync(this); 7004 _la = _input.LA(1); 7005 } 7006 setState(869); 7007 match(CLOSE); 7008 } 7009 } 7010 catch (RecognitionException re) { 7011 _localctx.exception = re; 7012 _errHandler.reportError(this, re); 7013 _errHandler.recover(this, re); 7014 } 7015 finally { 7016 exitRule(); 7017 } 7018 return _localctx; 7019 } 7020 7021 public static class DtTagCloseContext extends ParserRuleContext { 7022 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7023 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7024 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 7025 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7026 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7027 public TerminalNode NEWLINE(int i) { 7028 return getToken(JavadocParser.NEWLINE, i); 7029 } 7030 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7031 public TerminalNode LEADING_ASTERISK(int i) { 7032 return getToken(JavadocParser.LEADING_ASTERISK, i); 7033 } 7034 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7035 public TerminalNode WS(int i) { 7036 return getToken(JavadocParser.WS, i); 7037 } 7038 public DtTagCloseContext(ParserRuleContext parent, int invokingState) { 7039 super(parent, invokingState); 7040 } 7041 @Override public int getRuleIndex() { return RULE_dtTagClose; } 7042 @Override 7043 public void enterRule(ParseTreeListener listener) { 7044 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagClose(this); 7045 } 7046 @Override 7047 public void exitRule(ParseTreeListener listener) { 7048 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagClose(this); 7049 } 7050 @Override 7051 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7052 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagClose(this); 7053 else return visitor.visitChildren(this); 7054 } 7055 } 7056 7057 public final DtTagCloseContext dtTagClose() throws RecognitionException { 7058 DtTagCloseContext _localctx = new DtTagCloseContext(_ctx, getState()); 7059 enterRule(_localctx, 62, RULE_dtTagClose); 7060 int _la; 7061 try { 7062 enterOuterAlt(_localctx, 1); 7063 { 7064 setState(871); 7065 match(OPEN); 7066 setState(872); 7067 match(SLASH); 7068 setState(873); 7069 match(DT_HTML_TAG_NAME); 7070 setState(877); 7071 _errHandler.sync(this); 7072 _la = _input.LA(1); 7073 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7074 { 7075 { 7076 setState(874); 7077 _la = _input.LA(1); 7078 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7079 _errHandler.recoverInline(this); 7080 } else { 7081 consume(); 7082 } 7083 } 7084 } 7085 setState(879); 7086 _errHandler.sync(this); 7087 _la = _input.LA(1); 7088 } 7089 setState(880); 7090 match(CLOSE); 7091 } 7092 } 7093 catch (RecognitionException re) { 7094 _localctx.exception = re; 7095 _errHandler.reportError(this, re); 7096 _errHandler.recover(this, re); 7097 } 7098 finally { 7099 exitRule(); 7100 } 7101 return _localctx; 7102 } 7103 7104 public static class DtContext extends ParserRuleContext { 7105 public DtTagOpenContext dtTagOpen() { 7106 return getRuleContext(DtTagOpenContext.class,0); 7107 } 7108 public DtTagCloseContext dtTagClose() { 7109 return getRuleContext(DtTagCloseContext.class,0); 7110 } 7111 public List<HtmlTagContext> htmlTag() { 7112 return getRuleContexts(HtmlTagContext.class); 7113 } 7114 public HtmlTagContext htmlTag(int i) { 7115 return getRuleContext(HtmlTagContext.class,i); 7116 } 7117 public List<SingletonTagContext> singletonTag() { 7118 return getRuleContexts(SingletonTagContext.class); 7119 } 7120 public SingletonTagContext singletonTag(int i) { 7121 return getRuleContext(SingletonTagContext.class,i); 7122 } 7123 public List<ParagraphContext> paragraph() { 7124 return getRuleContexts(ParagraphContext.class); 7125 } 7126 public ParagraphContext paragraph(int i) { 7127 return getRuleContext(ParagraphContext.class,i); 7128 } 7129 public List<LiContext> li() { 7130 return getRuleContexts(LiContext.class); 7131 } 7132 public LiContext li(int i) { 7133 return getRuleContext(LiContext.class,i); 7134 } 7135 public List<TrContext> tr() { 7136 return getRuleContexts(TrContext.class); 7137 } 7138 public TrContext tr(int i) { 7139 return getRuleContext(TrContext.class,i); 7140 } 7141 public List<TdContext> td() { 7142 return getRuleContexts(TdContext.class); 7143 } 7144 public TdContext td(int i) { 7145 return getRuleContext(TdContext.class,i); 7146 } 7147 public List<ThContext> th() { 7148 return getRuleContexts(ThContext.class); 7149 } 7150 public ThContext th(int i) { 7151 return getRuleContext(ThContext.class,i); 7152 } 7153 public List<BodyContext> body() { 7154 return getRuleContexts(BodyContext.class); 7155 } 7156 public BodyContext body(int i) { 7157 return getRuleContext(BodyContext.class,i); 7158 } 7159 public List<ColgroupContext> colgroup() { 7160 return getRuleContexts(ColgroupContext.class); 7161 } 7162 public ColgroupContext colgroup(int i) { 7163 return getRuleContext(ColgroupContext.class,i); 7164 } 7165 public List<DdContext> dd() { 7166 return getRuleContexts(DdContext.class); 7167 } 7168 public DdContext dd(int i) { 7169 return getRuleContext(DdContext.class,i); 7170 } 7171 public List<HeadContext> head() { 7172 return getRuleContexts(HeadContext.class); 7173 } 7174 public HeadContext head(int i) { 7175 return getRuleContext(HeadContext.class,i); 7176 } 7177 public List<HtmlContext> html() { 7178 return getRuleContexts(HtmlContext.class); 7179 } 7180 public HtmlContext html(int i) { 7181 return getRuleContext(HtmlContext.class,i); 7182 } 7183 public List<OptionContext> option() { 7184 return getRuleContexts(OptionContext.class); 7185 } 7186 public OptionContext option(int i) { 7187 return getRuleContext(OptionContext.class,i); 7188 } 7189 public List<TbodyContext> tbody() { 7190 return getRuleContexts(TbodyContext.class); 7191 } 7192 public TbodyContext tbody(int i) { 7193 return getRuleContext(TbodyContext.class,i); 7194 } 7195 public List<TheadContext> thead() { 7196 return getRuleContexts(TheadContext.class); 7197 } 7198 public TheadContext thead(int i) { 7199 return getRuleContext(TheadContext.class,i); 7200 } 7201 public List<TfootContext> tfoot() { 7202 return getRuleContexts(TfootContext.class); 7203 } 7204 public TfootContext tfoot(int i) { 7205 return getRuleContext(TfootContext.class,i); 7206 } 7207 public List<PTagOpenContext> pTagOpen() { 7208 return getRuleContexts(PTagOpenContext.class); 7209 } 7210 public PTagOpenContext pTagOpen(int i) { 7211 return getRuleContext(PTagOpenContext.class,i); 7212 } 7213 public List<LiTagOpenContext> liTagOpen() { 7214 return getRuleContexts(LiTagOpenContext.class); 7215 } 7216 public LiTagOpenContext liTagOpen(int i) { 7217 return getRuleContext(LiTagOpenContext.class,i); 7218 } 7219 public List<TrTagOpenContext> trTagOpen() { 7220 return getRuleContexts(TrTagOpenContext.class); 7221 } 7222 public TrTagOpenContext trTagOpen(int i) { 7223 return getRuleContext(TrTagOpenContext.class,i); 7224 } 7225 public List<TdTagOpenContext> tdTagOpen() { 7226 return getRuleContexts(TdTagOpenContext.class); 7227 } 7228 public TdTagOpenContext tdTagOpen(int i) { 7229 return getRuleContext(TdTagOpenContext.class,i); 7230 } 7231 public List<ThTagOpenContext> thTagOpen() { 7232 return getRuleContexts(ThTagOpenContext.class); 7233 } 7234 public ThTagOpenContext thTagOpen(int i) { 7235 return getRuleContext(ThTagOpenContext.class,i); 7236 } 7237 public List<BodyTagOpenContext> bodyTagOpen() { 7238 return getRuleContexts(BodyTagOpenContext.class); 7239 } 7240 public BodyTagOpenContext bodyTagOpen(int i) { 7241 return getRuleContext(BodyTagOpenContext.class,i); 7242 } 7243 public List<ColgroupTagOpenContext> colgroupTagOpen() { 7244 return getRuleContexts(ColgroupTagOpenContext.class); 7245 } 7246 public ColgroupTagOpenContext colgroupTagOpen(int i) { 7247 return getRuleContext(ColgroupTagOpenContext.class,i); 7248 } 7249 public List<DdTagOpenContext> ddTagOpen() { 7250 return getRuleContexts(DdTagOpenContext.class); 7251 } 7252 public DdTagOpenContext ddTagOpen(int i) { 7253 return getRuleContext(DdTagOpenContext.class,i); 7254 } 7255 public List<HeadTagOpenContext> headTagOpen() { 7256 return getRuleContexts(HeadTagOpenContext.class); 7257 } 7258 public HeadTagOpenContext headTagOpen(int i) { 7259 return getRuleContext(HeadTagOpenContext.class,i); 7260 } 7261 public List<HtmlTagOpenContext> htmlTagOpen() { 7262 return getRuleContexts(HtmlTagOpenContext.class); 7263 } 7264 public HtmlTagOpenContext htmlTagOpen(int i) { 7265 return getRuleContext(HtmlTagOpenContext.class,i); 7266 } 7267 public List<OptionTagOpenContext> optionTagOpen() { 7268 return getRuleContexts(OptionTagOpenContext.class); 7269 } 7270 public OptionTagOpenContext optionTagOpen(int i) { 7271 return getRuleContext(OptionTagOpenContext.class,i); 7272 } 7273 public List<TbodyTagOpenContext> tbodyTagOpen() { 7274 return getRuleContexts(TbodyTagOpenContext.class); 7275 } 7276 public TbodyTagOpenContext tbodyTagOpen(int i) { 7277 return getRuleContext(TbodyTagOpenContext.class,i); 7278 } 7279 public List<TheadTagOpenContext> theadTagOpen() { 7280 return getRuleContexts(TheadTagOpenContext.class); 7281 } 7282 public TheadTagOpenContext theadTagOpen(int i) { 7283 return getRuleContext(TheadTagOpenContext.class,i); 7284 } 7285 public List<TfootTagOpenContext> tfootTagOpen() { 7286 return getRuleContexts(TfootTagOpenContext.class); 7287 } 7288 public TfootTagOpenContext tfootTagOpen(int i) { 7289 return getRuleContext(TfootTagOpenContext.class,i); 7290 } 7291 public List<HtmlCommentContext> htmlComment() { 7292 return getRuleContexts(HtmlCommentContext.class); 7293 } 7294 public HtmlCommentContext htmlComment(int i) { 7295 return getRuleContext(HtmlCommentContext.class,i); 7296 } 7297 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 7298 public TerminalNode CDATA(int i) { 7299 return getToken(JavadocParser.CDATA, i); 7300 } 7301 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7302 public TerminalNode NEWLINE(int i) { 7303 return getToken(JavadocParser.NEWLINE, i); 7304 } 7305 public List<TextContext> text() { 7306 return getRuleContexts(TextContext.class); 7307 } 7308 public TextContext text(int i) { 7309 return getRuleContext(TextContext.class,i); 7310 } 7311 public List<JavadocInlineTagContext> javadocInlineTag() { 7312 return getRuleContexts(JavadocInlineTagContext.class); 7313 } 7314 public JavadocInlineTagContext javadocInlineTag(int i) { 7315 return getRuleContext(JavadocInlineTagContext.class,i); 7316 } 7317 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7318 public TerminalNode LEADING_ASTERISK(int i) { 7319 return getToken(JavadocParser.LEADING_ASTERISK, i); 7320 } 7321 public DtContext(ParserRuleContext parent, int invokingState) { 7322 super(parent, invokingState); 7323 } 7324 @Override public int getRuleIndex() { return RULE_dt; } 7325 @Override 7326 public void enterRule(ParseTreeListener listener) { 7327 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDt(this); 7328 } 7329 @Override 7330 public void exitRule(ParseTreeListener listener) { 7331 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDt(this); 7332 } 7333 @Override 7334 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7335 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDt(this); 7336 else return visitor.visitChildren(this); 7337 } 7338 } 7339 7340 public final DtContext dt() throws RecognitionException { 7341 DtContext _localctx = new DtContext(_ctx, getState()); 7342 enterRule(_localctx, 64, RULE_dt); 7343 try { 7344 int _alt; 7345 enterOuterAlt(_localctx, 1); 7346 { 7347 setState(882); 7348 dtTagOpen(); 7349 setState(922); 7350 _errHandler.sync(this); 7351 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 7352 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 7353 if ( _alt==1 ) { 7354 { 7355 setState(920); 7356 _errHandler.sync(this); 7357 switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { 7358 case 1: 7359 { 7360 setState(883); 7361 htmlTag(); 7362 } 7363 break; 7364 case 2: 7365 { 7366 setState(884); 7367 singletonTag(); 7368 } 7369 break; 7370 case 3: 7371 { 7372 setState(885); 7373 paragraph(); 7374 } 7375 break; 7376 case 4: 7377 { 7378 setState(886); 7379 li(); 7380 } 7381 break; 7382 case 5: 7383 { 7384 setState(887); 7385 tr(); 7386 } 7387 break; 7388 case 6: 7389 { 7390 setState(888); 7391 td(); 7392 } 7393 break; 7394 case 7: 7395 { 7396 setState(889); 7397 th(); 7398 } 7399 break; 7400 case 8: 7401 { 7402 setState(890); 7403 body(); 7404 } 7405 break; 7406 case 9: 7407 { 7408 setState(891); 7409 colgroup(); 7410 } 7411 break; 7412 case 10: 7413 { 7414 setState(892); 7415 dd(); 7416 } 7417 break; 7418 case 11: 7419 { 7420 setState(893); 7421 head(); 7422 } 7423 break; 7424 case 12: 7425 { 7426 setState(894); 7427 html(); 7428 } 7429 break; 7430 case 13: 7431 { 7432 setState(895); 7433 option(); 7434 } 7435 break; 7436 case 14: 7437 { 7438 setState(896); 7439 tbody(); 7440 } 7441 break; 7442 case 15: 7443 { 7444 setState(897); 7445 thead(); 7446 } 7447 break; 7448 case 16: 7449 { 7450 setState(898); 7451 tfoot(); 7452 } 7453 break; 7454 case 17: 7455 { 7456 setState(899); 7457 pTagOpen(); 7458 } 7459 break; 7460 case 18: 7461 { 7462 setState(900); 7463 liTagOpen(); 7464 } 7465 break; 7466 case 19: 7467 { 7468 setState(901); 7469 trTagOpen(); 7470 } 7471 break; 7472 case 20: 7473 { 7474 setState(902); 7475 tdTagOpen(); 7476 } 7477 break; 7478 case 21: 7479 { 7480 setState(903); 7481 thTagOpen(); 7482 } 7483 break; 7484 case 22: 7485 { 7486 setState(904); 7487 bodyTagOpen(); 7488 } 7489 break; 7490 case 23: 7491 { 7492 setState(905); 7493 colgroupTagOpen(); 7494 } 7495 break; 7496 case 24: 7497 { 7498 setState(906); 7499 ddTagOpen(); 7500 } 7501 break; 7502 case 25: 7503 { 7504 setState(907); 7505 headTagOpen(); 7506 } 7507 break; 7508 case 26: 7509 { 7510 setState(908); 7511 htmlTagOpen(); 7512 } 7513 break; 7514 case 27: 7515 { 7516 setState(909); 7517 optionTagOpen(); 7518 } 7519 break; 7520 case 28: 7521 { 7522 setState(910); 7523 tbodyTagOpen(); 7524 } 7525 break; 7526 case 29: 7527 { 7528 setState(911); 7529 theadTagOpen(); 7530 } 7531 break; 7532 case 30: 7533 { 7534 setState(912); 7535 tfootTagOpen(); 7536 } 7537 break; 7538 case 31: 7539 { 7540 { 7541 setState(913); 7542 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 7543 setState(914); 7544 match(LEADING_ASTERISK); 7545 } 7546 } 7547 break; 7548 case 32: 7549 { 7550 setState(915); 7551 htmlComment(); 7552 } 7553 break; 7554 case 33: 7555 { 7556 setState(916); 7557 match(CDATA); 7558 } 7559 break; 7560 case 34: 7561 { 7562 setState(917); 7563 match(NEWLINE); 7564 } 7565 break; 7566 case 35: 7567 { 7568 setState(918); 7569 text(); 7570 } 7571 break; 7572 case 36: 7573 { 7574 setState(919); 7575 javadocInlineTag(); 7576 } 7577 break; 7578 } 7579 } 7580 } 7581 setState(924); 7582 _errHandler.sync(this); 7583 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 7584 } 7585 setState(925); 7586 dtTagClose(); 7587 } 7588 } 7589 catch (RecognitionException re) { 7590 _localctx.exception = re; 7591 _errHandler.reportError(this, re); 7592 _errHandler.recover(this, re); 7593 } 7594 finally { 7595 exitRule(); 7596 } 7597 return _localctx; 7598 } 7599 7600 public static class HeadTagOpenContext extends ParserRuleContext { 7601 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7602 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7603 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7604 public List<AttributeContext> attribute() { 7605 return getRuleContexts(AttributeContext.class); 7606 } 7607 public AttributeContext attribute(int i) { 7608 return getRuleContext(AttributeContext.class,i); 7609 } 7610 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7611 public TerminalNode NEWLINE(int i) { 7612 return getToken(JavadocParser.NEWLINE, i); 7613 } 7614 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7615 public TerminalNode LEADING_ASTERISK(int i) { 7616 return getToken(JavadocParser.LEADING_ASTERISK, i); 7617 } 7618 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7619 public TerminalNode WS(int i) { 7620 return getToken(JavadocParser.WS, i); 7621 } 7622 public HeadTagOpenContext(ParserRuleContext parent, int invokingState) { 7623 super(parent, invokingState); 7624 } 7625 @Override public int getRuleIndex() { return RULE_headTagOpen; } 7626 @Override 7627 public void enterRule(ParseTreeListener listener) { 7628 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagOpen(this); 7629 } 7630 @Override 7631 public void exitRule(ParseTreeListener listener) { 7632 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagOpen(this); 7633 } 7634 @Override 7635 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7636 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagOpen(this); 7637 else return visitor.visitChildren(this); 7638 } 7639 } 7640 7641 public final HeadTagOpenContext headTagOpen() throws RecognitionException { 7642 HeadTagOpenContext _localctx = new HeadTagOpenContext(_ctx, getState()); 7643 enterRule(_localctx, 66, RULE_headTagOpen); 7644 int _la; 7645 try { 7646 enterOuterAlt(_localctx, 1); 7647 { 7648 setState(927); 7649 match(OPEN); 7650 setState(928); 7651 match(HEAD_HTML_TAG_NAME); 7652 setState(935); 7653 _errHandler.sync(this); 7654 _la = _input.LA(1); 7655 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 7656 { 7657 setState(933); 7658 switch (_input.LA(1)) { 7659 case HTML_TAG_NAME: 7660 { 7661 setState(929); 7662 attribute(); 7663 } 7664 break; 7665 case NEWLINE: 7666 { 7667 setState(930); 7668 match(NEWLINE); 7669 } 7670 break; 7671 case LEADING_ASTERISK: 7672 { 7673 setState(931); 7674 match(LEADING_ASTERISK); 7675 } 7676 break; 7677 case WS: 7678 { 7679 setState(932); 7680 match(WS); 7681 } 7682 break; 7683 default: 7684 throw new NoViableAltException(this); 7685 } 7686 } 7687 setState(937); 7688 _errHandler.sync(this); 7689 _la = _input.LA(1); 7690 } 7691 setState(938); 7692 match(CLOSE); 7693 } 7694 } 7695 catch (RecognitionException re) { 7696 _localctx.exception = re; 7697 _errHandler.reportError(this, re); 7698 _errHandler.recover(this, re); 7699 } 7700 finally { 7701 exitRule(); 7702 } 7703 return _localctx; 7704 } 7705 7706 public static class HeadTagCloseContext extends ParserRuleContext { 7707 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7708 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7709 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7710 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7711 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7712 public TerminalNode NEWLINE(int i) { 7713 return getToken(JavadocParser.NEWLINE, i); 7714 } 7715 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7716 public TerminalNode LEADING_ASTERISK(int i) { 7717 return getToken(JavadocParser.LEADING_ASTERISK, i); 7718 } 7719 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7720 public TerminalNode WS(int i) { 7721 return getToken(JavadocParser.WS, i); 7722 } 7723 public HeadTagCloseContext(ParserRuleContext parent, int invokingState) { 7724 super(parent, invokingState); 7725 } 7726 @Override public int getRuleIndex() { return RULE_headTagClose; } 7727 @Override 7728 public void enterRule(ParseTreeListener listener) { 7729 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagClose(this); 7730 } 7731 @Override 7732 public void exitRule(ParseTreeListener listener) { 7733 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagClose(this); 7734 } 7735 @Override 7736 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7737 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagClose(this); 7738 else return visitor.visitChildren(this); 7739 } 7740 } 7741 7742 public final HeadTagCloseContext headTagClose() throws RecognitionException { 7743 HeadTagCloseContext _localctx = new HeadTagCloseContext(_ctx, getState()); 7744 enterRule(_localctx, 68, RULE_headTagClose); 7745 int _la; 7746 try { 7747 enterOuterAlt(_localctx, 1); 7748 { 7749 setState(940); 7750 match(OPEN); 7751 setState(941); 7752 match(SLASH); 7753 setState(942); 7754 match(HEAD_HTML_TAG_NAME); 7755 setState(946); 7756 _errHandler.sync(this); 7757 _la = _input.LA(1); 7758 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7759 { 7760 { 7761 setState(943); 7762 _la = _input.LA(1); 7763 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7764 _errHandler.recoverInline(this); 7765 } else { 7766 consume(); 7767 } 7768 } 7769 } 7770 setState(948); 7771 _errHandler.sync(this); 7772 _la = _input.LA(1); 7773 } 7774 setState(949); 7775 match(CLOSE); 7776 } 7777 } 7778 catch (RecognitionException re) { 7779 _localctx.exception = re; 7780 _errHandler.reportError(this, re); 7781 _errHandler.recover(this, re); 7782 } 7783 finally { 7784 exitRule(); 7785 } 7786 return _localctx; 7787 } 7788 7789 public static class HeadContext extends ParserRuleContext { 7790 public HeadTagOpenContext headTagOpen() { 7791 return getRuleContext(HeadTagOpenContext.class,0); 7792 } 7793 public HeadTagCloseContext headTagClose() { 7794 return getRuleContext(HeadTagCloseContext.class,0); 7795 } 7796 public List<HtmlTagContext> htmlTag() { 7797 return getRuleContexts(HtmlTagContext.class); 7798 } 7799 public HtmlTagContext htmlTag(int i) { 7800 return getRuleContext(HtmlTagContext.class,i); 7801 } 7802 public List<SingletonTagContext> singletonTag() { 7803 return getRuleContexts(SingletonTagContext.class); 7804 } 7805 public SingletonTagContext singletonTag(int i) { 7806 return getRuleContext(SingletonTagContext.class,i); 7807 } 7808 public List<ParagraphContext> paragraph() { 7809 return getRuleContexts(ParagraphContext.class); 7810 } 7811 public ParagraphContext paragraph(int i) { 7812 return getRuleContext(ParagraphContext.class,i); 7813 } 7814 public List<LiContext> li() { 7815 return getRuleContexts(LiContext.class); 7816 } 7817 public LiContext li(int i) { 7818 return getRuleContext(LiContext.class,i); 7819 } 7820 public List<TrContext> tr() { 7821 return getRuleContexts(TrContext.class); 7822 } 7823 public TrContext tr(int i) { 7824 return getRuleContext(TrContext.class,i); 7825 } 7826 public List<TdContext> td() { 7827 return getRuleContexts(TdContext.class); 7828 } 7829 public TdContext td(int i) { 7830 return getRuleContext(TdContext.class,i); 7831 } 7832 public List<ThContext> th() { 7833 return getRuleContexts(ThContext.class); 7834 } 7835 public ThContext th(int i) { 7836 return getRuleContext(ThContext.class,i); 7837 } 7838 public List<BodyContext> body() { 7839 return getRuleContexts(BodyContext.class); 7840 } 7841 public BodyContext body(int i) { 7842 return getRuleContext(BodyContext.class,i); 7843 } 7844 public List<ColgroupContext> colgroup() { 7845 return getRuleContexts(ColgroupContext.class); 7846 } 7847 public ColgroupContext colgroup(int i) { 7848 return getRuleContext(ColgroupContext.class,i); 7849 } 7850 public List<DdContext> dd() { 7851 return getRuleContexts(DdContext.class); 7852 } 7853 public DdContext dd(int i) { 7854 return getRuleContext(DdContext.class,i); 7855 } 7856 public List<DtContext> dt() { 7857 return getRuleContexts(DtContext.class); 7858 } 7859 public DtContext dt(int i) { 7860 return getRuleContext(DtContext.class,i); 7861 } 7862 public List<HtmlContext> html() { 7863 return getRuleContexts(HtmlContext.class); 7864 } 7865 public HtmlContext html(int i) { 7866 return getRuleContext(HtmlContext.class,i); 7867 } 7868 public List<OptionContext> option() { 7869 return getRuleContexts(OptionContext.class); 7870 } 7871 public OptionContext option(int i) { 7872 return getRuleContext(OptionContext.class,i); 7873 } 7874 public List<TbodyContext> tbody() { 7875 return getRuleContexts(TbodyContext.class); 7876 } 7877 public TbodyContext tbody(int i) { 7878 return getRuleContext(TbodyContext.class,i); 7879 } 7880 public List<TheadContext> thead() { 7881 return getRuleContexts(TheadContext.class); 7882 } 7883 public TheadContext thead(int i) { 7884 return getRuleContext(TheadContext.class,i); 7885 } 7886 public List<TfootContext> tfoot() { 7887 return getRuleContexts(TfootContext.class); 7888 } 7889 public TfootContext tfoot(int i) { 7890 return getRuleContext(TfootContext.class,i); 7891 } 7892 public List<PTagOpenContext> pTagOpen() { 7893 return getRuleContexts(PTagOpenContext.class); 7894 } 7895 public PTagOpenContext pTagOpen(int i) { 7896 return getRuleContext(PTagOpenContext.class,i); 7897 } 7898 public List<LiTagOpenContext> liTagOpen() { 7899 return getRuleContexts(LiTagOpenContext.class); 7900 } 7901 public LiTagOpenContext liTagOpen(int i) { 7902 return getRuleContext(LiTagOpenContext.class,i); 7903 } 7904 public List<TrTagOpenContext> trTagOpen() { 7905 return getRuleContexts(TrTagOpenContext.class); 7906 } 7907 public TrTagOpenContext trTagOpen(int i) { 7908 return getRuleContext(TrTagOpenContext.class,i); 7909 } 7910 public List<TdTagOpenContext> tdTagOpen() { 7911 return getRuleContexts(TdTagOpenContext.class); 7912 } 7913 public TdTagOpenContext tdTagOpen(int i) { 7914 return getRuleContext(TdTagOpenContext.class,i); 7915 } 7916 public List<ThTagOpenContext> thTagOpen() { 7917 return getRuleContexts(ThTagOpenContext.class); 7918 } 7919 public ThTagOpenContext thTagOpen(int i) { 7920 return getRuleContext(ThTagOpenContext.class,i); 7921 } 7922 public List<BodyTagOpenContext> bodyTagOpen() { 7923 return getRuleContexts(BodyTagOpenContext.class); 7924 } 7925 public BodyTagOpenContext bodyTagOpen(int i) { 7926 return getRuleContext(BodyTagOpenContext.class,i); 7927 } 7928 public List<ColgroupTagOpenContext> colgroupTagOpen() { 7929 return getRuleContexts(ColgroupTagOpenContext.class); 7930 } 7931 public ColgroupTagOpenContext colgroupTagOpen(int i) { 7932 return getRuleContext(ColgroupTagOpenContext.class,i); 7933 } 7934 public List<DdTagOpenContext> ddTagOpen() { 7935 return getRuleContexts(DdTagOpenContext.class); 7936 } 7937 public DdTagOpenContext ddTagOpen(int i) { 7938 return getRuleContext(DdTagOpenContext.class,i); 7939 } 7940 public List<DtTagOpenContext> dtTagOpen() { 7941 return getRuleContexts(DtTagOpenContext.class); 7942 } 7943 public DtTagOpenContext dtTagOpen(int i) { 7944 return getRuleContext(DtTagOpenContext.class,i); 7945 } 7946 public List<HtmlTagOpenContext> htmlTagOpen() { 7947 return getRuleContexts(HtmlTagOpenContext.class); 7948 } 7949 public HtmlTagOpenContext htmlTagOpen(int i) { 7950 return getRuleContext(HtmlTagOpenContext.class,i); 7951 } 7952 public List<OptionTagOpenContext> optionTagOpen() { 7953 return getRuleContexts(OptionTagOpenContext.class); 7954 } 7955 public OptionTagOpenContext optionTagOpen(int i) { 7956 return getRuleContext(OptionTagOpenContext.class,i); 7957 } 7958 public List<TbodyTagOpenContext> tbodyTagOpen() { 7959 return getRuleContexts(TbodyTagOpenContext.class); 7960 } 7961 public TbodyTagOpenContext tbodyTagOpen(int i) { 7962 return getRuleContext(TbodyTagOpenContext.class,i); 7963 } 7964 public List<TheadTagOpenContext> theadTagOpen() { 7965 return getRuleContexts(TheadTagOpenContext.class); 7966 } 7967 public TheadTagOpenContext theadTagOpen(int i) { 7968 return getRuleContext(TheadTagOpenContext.class,i); 7969 } 7970 public List<TfootTagOpenContext> tfootTagOpen() { 7971 return getRuleContexts(TfootTagOpenContext.class); 7972 } 7973 public TfootTagOpenContext tfootTagOpen(int i) { 7974 return getRuleContext(TfootTagOpenContext.class,i); 7975 } 7976 public List<HtmlCommentContext> htmlComment() { 7977 return getRuleContexts(HtmlCommentContext.class); 7978 } 7979 public HtmlCommentContext htmlComment(int i) { 7980 return getRuleContext(HtmlCommentContext.class,i); 7981 } 7982 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 7983 public TerminalNode CDATA(int i) { 7984 return getToken(JavadocParser.CDATA, i); 7985 } 7986 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7987 public TerminalNode NEWLINE(int i) { 7988 return getToken(JavadocParser.NEWLINE, i); 7989 } 7990 public List<TextContext> text() { 7991 return getRuleContexts(TextContext.class); 7992 } 7993 public TextContext text(int i) { 7994 return getRuleContext(TextContext.class,i); 7995 } 7996 public List<JavadocInlineTagContext> javadocInlineTag() { 7997 return getRuleContexts(JavadocInlineTagContext.class); 7998 } 7999 public JavadocInlineTagContext javadocInlineTag(int i) { 8000 return getRuleContext(JavadocInlineTagContext.class,i); 8001 } 8002 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8003 public TerminalNode LEADING_ASTERISK(int i) { 8004 return getToken(JavadocParser.LEADING_ASTERISK, i); 8005 } 8006 public HeadContext(ParserRuleContext parent, int invokingState) { 8007 super(parent, invokingState); 8008 } 8009 @Override public int getRuleIndex() { return RULE_head; } 8010 @Override 8011 public void enterRule(ParseTreeListener listener) { 8012 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHead(this); 8013 } 8014 @Override 8015 public void exitRule(ParseTreeListener listener) { 8016 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHead(this); 8017 } 8018 @Override 8019 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8020 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHead(this); 8021 else return visitor.visitChildren(this); 8022 } 8023 } 8024 8025 public final HeadContext head() throws RecognitionException { 8026 HeadContext _localctx = new HeadContext(_ctx, getState()); 8027 enterRule(_localctx, 70, RULE_head); 8028 try { 8029 int _alt; 8030 enterOuterAlt(_localctx, 1); 8031 { 8032 setState(951); 8033 headTagOpen(); 8034 setState(991); 8035 _errHandler.sync(this); 8036 _alt = getInterpreter().adaptivePredict(_input,66,_ctx); 8037 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8038 if ( _alt==1 ) { 8039 { 8040 setState(989); 8041 _errHandler.sync(this); 8042 switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) { 8043 case 1: 8044 { 8045 setState(952); 8046 htmlTag(); 8047 } 8048 break; 8049 case 2: 8050 { 8051 setState(953); 8052 singletonTag(); 8053 } 8054 break; 8055 case 3: 8056 { 8057 setState(954); 8058 paragraph(); 8059 } 8060 break; 8061 case 4: 8062 { 8063 setState(955); 8064 li(); 8065 } 8066 break; 8067 case 5: 8068 { 8069 setState(956); 8070 tr(); 8071 } 8072 break; 8073 case 6: 8074 { 8075 setState(957); 8076 td(); 8077 } 8078 break; 8079 case 7: 8080 { 8081 setState(958); 8082 th(); 8083 } 8084 break; 8085 case 8: 8086 { 8087 setState(959); 8088 body(); 8089 } 8090 break; 8091 case 9: 8092 { 8093 setState(960); 8094 colgroup(); 8095 } 8096 break; 8097 case 10: 8098 { 8099 setState(961); 8100 dd(); 8101 } 8102 break; 8103 case 11: 8104 { 8105 setState(962); 8106 dt(); 8107 } 8108 break; 8109 case 12: 8110 { 8111 setState(963); 8112 html(); 8113 } 8114 break; 8115 case 13: 8116 { 8117 setState(964); 8118 option(); 8119 } 8120 break; 8121 case 14: 8122 { 8123 setState(965); 8124 tbody(); 8125 } 8126 break; 8127 case 15: 8128 { 8129 setState(966); 8130 thead(); 8131 } 8132 break; 8133 case 16: 8134 { 8135 setState(967); 8136 tfoot(); 8137 } 8138 break; 8139 case 17: 8140 { 8141 setState(968); 8142 pTagOpen(); 8143 } 8144 break; 8145 case 18: 8146 { 8147 setState(969); 8148 liTagOpen(); 8149 } 8150 break; 8151 case 19: 8152 { 8153 setState(970); 8154 trTagOpen(); 8155 } 8156 break; 8157 case 20: 8158 { 8159 setState(971); 8160 tdTagOpen(); 8161 } 8162 break; 8163 case 21: 8164 { 8165 setState(972); 8166 thTagOpen(); 8167 } 8168 break; 8169 case 22: 8170 { 8171 setState(973); 8172 bodyTagOpen(); 8173 } 8174 break; 8175 case 23: 8176 { 8177 setState(974); 8178 colgroupTagOpen(); 8179 } 8180 break; 8181 case 24: 8182 { 8183 setState(975); 8184 ddTagOpen(); 8185 } 8186 break; 8187 case 25: 8188 { 8189 setState(976); 8190 dtTagOpen(); 8191 } 8192 break; 8193 case 26: 8194 { 8195 setState(977); 8196 htmlTagOpen(); 8197 } 8198 break; 8199 case 27: 8200 { 8201 setState(978); 8202 optionTagOpen(); 8203 } 8204 break; 8205 case 28: 8206 { 8207 setState(979); 8208 tbodyTagOpen(); 8209 } 8210 break; 8211 case 29: 8212 { 8213 setState(980); 8214 theadTagOpen(); 8215 } 8216 break; 8217 case 30: 8218 { 8219 setState(981); 8220 tfootTagOpen(); 8221 } 8222 break; 8223 case 31: 8224 { 8225 { 8226 setState(982); 8227 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8228 setState(983); 8229 match(LEADING_ASTERISK); 8230 } 8231 } 8232 break; 8233 case 32: 8234 { 8235 setState(984); 8236 htmlComment(); 8237 } 8238 break; 8239 case 33: 8240 { 8241 setState(985); 8242 match(CDATA); 8243 } 8244 break; 8245 case 34: 8246 { 8247 setState(986); 8248 match(NEWLINE); 8249 } 8250 break; 8251 case 35: 8252 { 8253 setState(987); 8254 text(); 8255 } 8256 break; 8257 case 36: 8258 { 8259 setState(988); 8260 javadocInlineTag(); 8261 } 8262 break; 8263 } 8264 } 8265 } 8266 setState(993); 8267 _errHandler.sync(this); 8268 _alt = getInterpreter().adaptivePredict(_input,66,_ctx); 8269 } 8270 setState(994); 8271 headTagClose(); 8272 } 8273 } 8274 catch (RecognitionException re) { 8275 _localctx.exception = re; 8276 _errHandler.reportError(this, re); 8277 _errHandler.recover(this, re); 8278 } 8279 finally { 8280 exitRule(); 8281 } 8282 return _localctx; 8283 } 8284 8285 public static class HtmlTagOpenContext extends ParserRuleContext { 8286 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8287 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 8288 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8289 public List<AttributeContext> attribute() { 8290 return getRuleContexts(AttributeContext.class); 8291 } 8292 public AttributeContext attribute(int i) { 8293 return getRuleContext(AttributeContext.class,i); 8294 } 8295 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8296 public TerminalNode NEWLINE(int i) { 8297 return getToken(JavadocParser.NEWLINE, i); 8298 } 8299 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8300 public TerminalNode LEADING_ASTERISK(int i) { 8301 return getToken(JavadocParser.LEADING_ASTERISK, i); 8302 } 8303 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8304 public TerminalNode WS(int i) { 8305 return getToken(JavadocParser.WS, i); 8306 } 8307 public HtmlTagOpenContext(ParserRuleContext parent, int invokingState) { 8308 super(parent, invokingState); 8309 } 8310 @Override public int getRuleIndex() { return RULE_htmlTagOpen; } 8311 @Override 8312 public void enterRule(ParseTreeListener listener) { 8313 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagOpen(this); 8314 } 8315 @Override 8316 public void exitRule(ParseTreeListener listener) { 8317 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagOpen(this); 8318 } 8319 @Override 8320 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8321 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagOpen(this); 8322 else return visitor.visitChildren(this); 8323 } 8324 } 8325 8326 public final HtmlTagOpenContext htmlTagOpen() throws RecognitionException { 8327 HtmlTagOpenContext _localctx = new HtmlTagOpenContext(_ctx, getState()); 8328 enterRule(_localctx, 72, RULE_htmlTagOpen); 8329 int _la; 8330 try { 8331 enterOuterAlt(_localctx, 1); 8332 { 8333 setState(996); 8334 match(OPEN); 8335 setState(997); 8336 match(HTML_HTML_TAG_NAME); 8337 setState(1004); 8338 _errHandler.sync(this); 8339 _la = _input.LA(1); 8340 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 8341 { 8342 setState(1002); 8343 switch (_input.LA(1)) { 8344 case HTML_TAG_NAME: 8345 { 8346 setState(998); 8347 attribute(); 8348 } 8349 break; 8350 case NEWLINE: 8351 { 8352 setState(999); 8353 match(NEWLINE); 8354 } 8355 break; 8356 case LEADING_ASTERISK: 8357 { 8358 setState(1000); 8359 match(LEADING_ASTERISK); 8360 } 8361 break; 8362 case WS: 8363 { 8364 setState(1001); 8365 match(WS); 8366 } 8367 break; 8368 default: 8369 throw new NoViableAltException(this); 8370 } 8371 } 8372 setState(1006); 8373 _errHandler.sync(this); 8374 _la = _input.LA(1); 8375 } 8376 setState(1007); 8377 match(CLOSE); 8378 } 8379 } 8380 catch (RecognitionException re) { 8381 _localctx.exception = re; 8382 _errHandler.reportError(this, re); 8383 _errHandler.recover(this, re); 8384 } 8385 finally { 8386 exitRule(); 8387 } 8388 return _localctx; 8389 } 8390 8391 public static class HtmlTagCloseContext extends ParserRuleContext { 8392 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8393 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 8394 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 8395 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8396 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8397 public TerminalNode NEWLINE(int i) { 8398 return getToken(JavadocParser.NEWLINE, i); 8399 } 8400 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8401 public TerminalNode LEADING_ASTERISK(int i) { 8402 return getToken(JavadocParser.LEADING_ASTERISK, i); 8403 } 8404 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8405 public TerminalNode WS(int i) { 8406 return getToken(JavadocParser.WS, i); 8407 } 8408 public HtmlTagCloseContext(ParserRuleContext parent, int invokingState) { 8409 super(parent, invokingState); 8410 } 8411 @Override public int getRuleIndex() { return RULE_htmlTagClose; } 8412 @Override 8413 public void enterRule(ParseTreeListener listener) { 8414 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagClose(this); 8415 } 8416 @Override 8417 public void exitRule(ParseTreeListener listener) { 8418 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagClose(this); 8419 } 8420 @Override 8421 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8422 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagClose(this); 8423 else return visitor.visitChildren(this); 8424 } 8425 } 8426 8427 public final HtmlTagCloseContext htmlTagClose() throws RecognitionException { 8428 HtmlTagCloseContext _localctx = new HtmlTagCloseContext(_ctx, getState()); 8429 enterRule(_localctx, 74, RULE_htmlTagClose); 8430 int _la; 8431 try { 8432 enterOuterAlt(_localctx, 1); 8433 { 8434 setState(1009); 8435 match(OPEN); 8436 setState(1010); 8437 match(SLASH); 8438 setState(1011); 8439 match(HTML_HTML_TAG_NAME); 8440 setState(1015); 8441 _errHandler.sync(this); 8442 _la = _input.LA(1); 8443 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 8444 { 8445 { 8446 setState(1012); 8447 _la = _input.LA(1); 8448 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 8449 _errHandler.recoverInline(this); 8450 } else { 8451 consume(); 8452 } 8453 } 8454 } 8455 setState(1017); 8456 _errHandler.sync(this); 8457 _la = _input.LA(1); 8458 } 8459 setState(1018); 8460 match(CLOSE); 8461 } 8462 } 8463 catch (RecognitionException re) { 8464 _localctx.exception = re; 8465 _errHandler.reportError(this, re); 8466 _errHandler.recover(this, re); 8467 } 8468 finally { 8469 exitRule(); 8470 } 8471 return _localctx; 8472 } 8473 8474 public static class HtmlContext extends ParserRuleContext { 8475 public HtmlTagOpenContext htmlTagOpen() { 8476 return getRuleContext(HtmlTagOpenContext.class,0); 8477 } 8478 public HtmlTagCloseContext htmlTagClose() { 8479 return getRuleContext(HtmlTagCloseContext.class,0); 8480 } 8481 public List<HtmlTagContext> htmlTag() { 8482 return getRuleContexts(HtmlTagContext.class); 8483 } 8484 public HtmlTagContext htmlTag(int i) { 8485 return getRuleContext(HtmlTagContext.class,i); 8486 } 8487 public List<SingletonTagContext> singletonTag() { 8488 return getRuleContexts(SingletonTagContext.class); 8489 } 8490 public SingletonTagContext singletonTag(int i) { 8491 return getRuleContext(SingletonTagContext.class,i); 8492 } 8493 public List<ParagraphContext> paragraph() { 8494 return getRuleContexts(ParagraphContext.class); 8495 } 8496 public ParagraphContext paragraph(int i) { 8497 return getRuleContext(ParagraphContext.class,i); 8498 } 8499 public List<LiContext> li() { 8500 return getRuleContexts(LiContext.class); 8501 } 8502 public LiContext li(int i) { 8503 return getRuleContext(LiContext.class,i); 8504 } 8505 public List<TrContext> tr() { 8506 return getRuleContexts(TrContext.class); 8507 } 8508 public TrContext tr(int i) { 8509 return getRuleContext(TrContext.class,i); 8510 } 8511 public List<TdContext> td() { 8512 return getRuleContexts(TdContext.class); 8513 } 8514 public TdContext td(int i) { 8515 return getRuleContext(TdContext.class,i); 8516 } 8517 public List<ThContext> th() { 8518 return getRuleContexts(ThContext.class); 8519 } 8520 public ThContext th(int i) { 8521 return getRuleContext(ThContext.class,i); 8522 } 8523 public List<BodyContext> body() { 8524 return getRuleContexts(BodyContext.class); 8525 } 8526 public BodyContext body(int i) { 8527 return getRuleContext(BodyContext.class,i); 8528 } 8529 public List<ColgroupContext> colgroup() { 8530 return getRuleContexts(ColgroupContext.class); 8531 } 8532 public ColgroupContext colgroup(int i) { 8533 return getRuleContext(ColgroupContext.class,i); 8534 } 8535 public List<DdContext> dd() { 8536 return getRuleContexts(DdContext.class); 8537 } 8538 public DdContext dd(int i) { 8539 return getRuleContext(DdContext.class,i); 8540 } 8541 public List<DtContext> dt() { 8542 return getRuleContexts(DtContext.class); 8543 } 8544 public DtContext dt(int i) { 8545 return getRuleContext(DtContext.class,i); 8546 } 8547 public List<HeadContext> head() { 8548 return getRuleContexts(HeadContext.class); 8549 } 8550 public HeadContext head(int i) { 8551 return getRuleContext(HeadContext.class,i); 8552 } 8553 public List<OptionContext> option() { 8554 return getRuleContexts(OptionContext.class); 8555 } 8556 public OptionContext option(int i) { 8557 return getRuleContext(OptionContext.class,i); 8558 } 8559 public List<TbodyContext> tbody() { 8560 return getRuleContexts(TbodyContext.class); 8561 } 8562 public TbodyContext tbody(int i) { 8563 return getRuleContext(TbodyContext.class,i); 8564 } 8565 public List<TheadContext> thead() { 8566 return getRuleContexts(TheadContext.class); 8567 } 8568 public TheadContext thead(int i) { 8569 return getRuleContext(TheadContext.class,i); 8570 } 8571 public List<TfootContext> tfoot() { 8572 return getRuleContexts(TfootContext.class); 8573 } 8574 public TfootContext tfoot(int i) { 8575 return getRuleContext(TfootContext.class,i); 8576 } 8577 public List<PTagOpenContext> pTagOpen() { 8578 return getRuleContexts(PTagOpenContext.class); 8579 } 8580 public PTagOpenContext pTagOpen(int i) { 8581 return getRuleContext(PTagOpenContext.class,i); 8582 } 8583 public List<LiTagOpenContext> liTagOpen() { 8584 return getRuleContexts(LiTagOpenContext.class); 8585 } 8586 public LiTagOpenContext liTagOpen(int i) { 8587 return getRuleContext(LiTagOpenContext.class,i); 8588 } 8589 public List<TrTagOpenContext> trTagOpen() { 8590 return getRuleContexts(TrTagOpenContext.class); 8591 } 8592 public TrTagOpenContext trTagOpen(int i) { 8593 return getRuleContext(TrTagOpenContext.class,i); 8594 } 8595 public List<TdTagOpenContext> tdTagOpen() { 8596 return getRuleContexts(TdTagOpenContext.class); 8597 } 8598 public TdTagOpenContext tdTagOpen(int i) { 8599 return getRuleContext(TdTagOpenContext.class,i); 8600 } 8601 public List<ThTagOpenContext> thTagOpen() { 8602 return getRuleContexts(ThTagOpenContext.class); 8603 } 8604 public ThTagOpenContext thTagOpen(int i) { 8605 return getRuleContext(ThTagOpenContext.class,i); 8606 } 8607 public List<BodyTagOpenContext> bodyTagOpen() { 8608 return getRuleContexts(BodyTagOpenContext.class); 8609 } 8610 public BodyTagOpenContext bodyTagOpen(int i) { 8611 return getRuleContext(BodyTagOpenContext.class,i); 8612 } 8613 public List<ColgroupTagOpenContext> colgroupTagOpen() { 8614 return getRuleContexts(ColgroupTagOpenContext.class); 8615 } 8616 public ColgroupTagOpenContext colgroupTagOpen(int i) { 8617 return getRuleContext(ColgroupTagOpenContext.class,i); 8618 } 8619 public List<DdTagOpenContext> ddTagOpen() { 8620 return getRuleContexts(DdTagOpenContext.class); 8621 } 8622 public DdTagOpenContext ddTagOpen(int i) { 8623 return getRuleContext(DdTagOpenContext.class,i); 8624 } 8625 public List<DtTagOpenContext> dtTagOpen() { 8626 return getRuleContexts(DtTagOpenContext.class); 8627 } 8628 public DtTagOpenContext dtTagOpen(int i) { 8629 return getRuleContext(DtTagOpenContext.class,i); 8630 } 8631 public List<HeadTagOpenContext> headTagOpen() { 8632 return getRuleContexts(HeadTagOpenContext.class); 8633 } 8634 public HeadTagOpenContext headTagOpen(int i) { 8635 return getRuleContext(HeadTagOpenContext.class,i); 8636 } 8637 public List<OptionTagOpenContext> optionTagOpen() { 8638 return getRuleContexts(OptionTagOpenContext.class); 8639 } 8640 public OptionTagOpenContext optionTagOpen(int i) { 8641 return getRuleContext(OptionTagOpenContext.class,i); 8642 } 8643 public List<TbodyTagOpenContext> tbodyTagOpen() { 8644 return getRuleContexts(TbodyTagOpenContext.class); 8645 } 8646 public TbodyTagOpenContext tbodyTagOpen(int i) { 8647 return getRuleContext(TbodyTagOpenContext.class,i); 8648 } 8649 public List<TheadTagOpenContext> theadTagOpen() { 8650 return getRuleContexts(TheadTagOpenContext.class); 8651 } 8652 public TheadTagOpenContext theadTagOpen(int i) { 8653 return getRuleContext(TheadTagOpenContext.class,i); 8654 } 8655 public List<TfootTagOpenContext> tfootTagOpen() { 8656 return getRuleContexts(TfootTagOpenContext.class); 8657 } 8658 public TfootTagOpenContext tfootTagOpen(int i) { 8659 return getRuleContext(TfootTagOpenContext.class,i); 8660 } 8661 public List<HtmlCommentContext> htmlComment() { 8662 return getRuleContexts(HtmlCommentContext.class); 8663 } 8664 public HtmlCommentContext htmlComment(int i) { 8665 return getRuleContext(HtmlCommentContext.class,i); 8666 } 8667 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8668 public TerminalNode CDATA(int i) { 8669 return getToken(JavadocParser.CDATA, i); 8670 } 8671 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8672 public TerminalNode NEWLINE(int i) { 8673 return getToken(JavadocParser.NEWLINE, i); 8674 } 8675 public List<TextContext> text() { 8676 return getRuleContexts(TextContext.class); 8677 } 8678 public TextContext text(int i) { 8679 return getRuleContext(TextContext.class,i); 8680 } 8681 public List<JavadocInlineTagContext> javadocInlineTag() { 8682 return getRuleContexts(JavadocInlineTagContext.class); 8683 } 8684 public JavadocInlineTagContext javadocInlineTag(int i) { 8685 return getRuleContext(JavadocInlineTagContext.class,i); 8686 } 8687 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8688 public TerminalNode LEADING_ASTERISK(int i) { 8689 return getToken(JavadocParser.LEADING_ASTERISK, i); 8690 } 8691 public HtmlContext(ParserRuleContext parent, int invokingState) { 8692 super(parent, invokingState); 8693 } 8694 @Override public int getRuleIndex() { return RULE_html; } 8695 @Override 8696 public void enterRule(ParseTreeListener listener) { 8697 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtml(this); 8698 } 8699 @Override 8700 public void exitRule(ParseTreeListener listener) { 8701 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtml(this); 8702 } 8703 @Override 8704 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8705 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtml(this); 8706 else return visitor.visitChildren(this); 8707 } 8708 } 8709 8710 public final HtmlContext html() throws RecognitionException { 8711 HtmlContext _localctx = new HtmlContext(_ctx, getState()); 8712 enterRule(_localctx, 76, RULE_html); 8713 try { 8714 int _alt; 8715 enterOuterAlt(_localctx, 1); 8716 { 8717 setState(1020); 8718 htmlTagOpen(); 8719 setState(1060); 8720 _errHandler.sync(this); 8721 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 8722 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8723 if ( _alt==1 ) { 8724 { 8725 setState(1058); 8726 _errHandler.sync(this); 8727 switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { 8728 case 1: 8729 { 8730 setState(1021); 8731 htmlTag(); 8732 } 8733 break; 8734 case 2: 8735 { 8736 setState(1022); 8737 singletonTag(); 8738 } 8739 break; 8740 case 3: 8741 { 8742 setState(1023); 8743 paragraph(); 8744 } 8745 break; 8746 case 4: 8747 { 8748 setState(1024); 8749 li(); 8750 } 8751 break; 8752 case 5: 8753 { 8754 setState(1025); 8755 tr(); 8756 } 8757 break; 8758 case 6: 8759 { 8760 setState(1026); 8761 td(); 8762 } 8763 break; 8764 case 7: 8765 { 8766 setState(1027); 8767 th(); 8768 } 8769 break; 8770 case 8: 8771 { 8772 setState(1028); 8773 body(); 8774 } 8775 break; 8776 case 9: 8777 { 8778 setState(1029); 8779 colgroup(); 8780 } 8781 break; 8782 case 10: 8783 { 8784 setState(1030); 8785 dd(); 8786 } 8787 break; 8788 case 11: 8789 { 8790 setState(1031); 8791 dt(); 8792 } 8793 break; 8794 case 12: 8795 { 8796 setState(1032); 8797 head(); 8798 } 8799 break; 8800 case 13: 8801 { 8802 setState(1033); 8803 option(); 8804 } 8805 break; 8806 case 14: 8807 { 8808 setState(1034); 8809 tbody(); 8810 } 8811 break; 8812 case 15: 8813 { 8814 setState(1035); 8815 thead(); 8816 } 8817 break; 8818 case 16: 8819 { 8820 setState(1036); 8821 tfoot(); 8822 } 8823 break; 8824 case 17: 8825 { 8826 setState(1037); 8827 pTagOpen(); 8828 } 8829 break; 8830 case 18: 8831 { 8832 setState(1038); 8833 liTagOpen(); 8834 } 8835 break; 8836 case 19: 8837 { 8838 setState(1039); 8839 trTagOpen(); 8840 } 8841 break; 8842 case 20: 8843 { 8844 setState(1040); 8845 tdTagOpen(); 8846 } 8847 break; 8848 case 21: 8849 { 8850 setState(1041); 8851 thTagOpen(); 8852 } 8853 break; 8854 case 22: 8855 { 8856 setState(1042); 8857 bodyTagOpen(); 8858 } 8859 break; 8860 case 23: 8861 { 8862 setState(1043); 8863 colgroupTagOpen(); 8864 } 8865 break; 8866 case 24: 8867 { 8868 setState(1044); 8869 ddTagOpen(); 8870 } 8871 break; 8872 case 25: 8873 { 8874 setState(1045); 8875 dtTagOpen(); 8876 } 8877 break; 8878 case 26: 8879 { 8880 setState(1046); 8881 headTagOpen(); 8882 } 8883 break; 8884 case 27: 8885 { 8886 setState(1047); 8887 optionTagOpen(); 8888 } 8889 break; 8890 case 28: 8891 { 8892 setState(1048); 8893 tbodyTagOpen(); 8894 } 8895 break; 8896 case 29: 8897 { 8898 setState(1049); 8899 theadTagOpen(); 8900 } 8901 break; 8902 case 30: 8903 { 8904 setState(1050); 8905 tfootTagOpen(); 8906 } 8907 break; 8908 case 31: 8909 { 8910 { 8911 setState(1051); 8912 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8913 setState(1052); 8914 match(LEADING_ASTERISK); 8915 } 8916 } 8917 break; 8918 case 32: 8919 { 8920 setState(1053); 8921 htmlComment(); 8922 } 8923 break; 8924 case 33: 8925 { 8926 setState(1054); 8927 match(CDATA); 8928 } 8929 break; 8930 case 34: 8931 { 8932 setState(1055); 8933 match(NEWLINE); 8934 } 8935 break; 8936 case 35: 8937 { 8938 setState(1056); 8939 text(); 8940 } 8941 break; 8942 case 36: 8943 { 8944 setState(1057); 8945 javadocInlineTag(); 8946 } 8947 break; 8948 } 8949 } 8950 } 8951 setState(1062); 8952 _errHandler.sync(this); 8953 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 8954 } 8955 setState(1063); 8956 htmlTagClose(); 8957 } 8958 } 8959 catch (RecognitionException re) { 8960 _localctx.exception = re; 8961 _errHandler.reportError(this, re); 8962 _errHandler.recover(this, re); 8963 } 8964 finally { 8965 exitRule(); 8966 } 8967 return _localctx; 8968 } 8969 8970 public static class OptionTagOpenContext extends ParserRuleContext { 8971 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8972 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 8973 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8974 public List<AttributeContext> attribute() { 8975 return getRuleContexts(AttributeContext.class); 8976 } 8977 public AttributeContext attribute(int i) { 8978 return getRuleContext(AttributeContext.class,i); 8979 } 8980 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8981 public TerminalNode NEWLINE(int i) { 8982 return getToken(JavadocParser.NEWLINE, i); 8983 } 8984 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8985 public TerminalNode LEADING_ASTERISK(int i) { 8986 return getToken(JavadocParser.LEADING_ASTERISK, i); 8987 } 8988 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8989 public TerminalNode WS(int i) { 8990 return getToken(JavadocParser.WS, i); 8991 } 8992 public OptionTagOpenContext(ParserRuleContext parent, int invokingState) { 8993 super(parent, invokingState); 8994 } 8995 @Override public int getRuleIndex() { return RULE_optionTagOpen; } 8996 @Override 8997 public void enterRule(ParseTreeListener listener) { 8998 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagOpen(this); 8999 } 9000 @Override 9001 public void exitRule(ParseTreeListener listener) { 9002 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagOpen(this); 9003 } 9004 @Override 9005 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9006 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagOpen(this); 9007 else return visitor.visitChildren(this); 9008 } 9009 } 9010 9011 public final OptionTagOpenContext optionTagOpen() throws RecognitionException { 9012 OptionTagOpenContext _localctx = new OptionTagOpenContext(_ctx, getState()); 9013 enterRule(_localctx, 78, RULE_optionTagOpen); 9014 int _la; 9015 try { 9016 enterOuterAlt(_localctx, 1); 9017 { 9018 setState(1065); 9019 match(OPEN); 9020 setState(1066); 9021 match(OPTION_HTML_TAG_NAME); 9022 setState(1073); 9023 _errHandler.sync(this); 9024 _la = _input.LA(1); 9025 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9026 { 9027 setState(1071); 9028 switch (_input.LA(1)) { 9029 case HTML_TAG_NAME: 9030 { 9031 setState(1067); 9032 attribute(); 9033 } 9034 break; 9035 case NEWLINE: 9036 { 9037 setState(1068); 9038 match(NEWLINE); 9039 } 9040 break; 9041 case LEADING_ASTERISK: 9042 { 9043 setState(1069); 9044 match(LEADING_ASTERISK); 9045 } 9046 break; 9047 case WS: 9048 { 9049 setState(1070); 9050 match(WS); 9051 } 9052 break; 9053 default: 9054 throw new NoViableAltException(this); 9055 } 9056 } 9057 setState(1075); 9058 _errHandler.sync(this); 9059 _la = _input.LA(1); 9060 } 9061 setState(1076); 9062 match(CLOSE); 9063 } 9064 } 9065 catch (RecognitionException re) { 9066 _localctx.exception = re; 9067 _errHandler.reportError(this, re); 9068 _errHandler.recover(this, re); 9069 } 9070 finally { 9071 exitRule(); 9072 } 9073 return _localctx; 9074 } 9075 9076 public static class OptionTagCloseContext extends ParserRuleContext { 9077 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9078 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9079 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 9080 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9081 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9082 public TerminalNode NEWLINE(int i) { 9083 return getToken(JavadocParser.NEWLINE, i); 9084 } 9085 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9086 public TerminalNode LEADING_ASTERISK(int i) { 9087 return getToken(JavadocParser.LEADING_ASTERISK, i); 9088 } 9089 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9090 public TerminalNode WS(int i) { 9091 return getToken(JavadocParser.WS, i); 9092 } 9093 public OptionTagCloseContext(ParserRuleContext parent, int invokingState) { 9094 super(parent, invokingState); 9095 } 9096 @Override public int getRuleIndex() { return RULE_optionTagClose; } 9097 @Override 9098 public void enterRule(ParseTreeListener listener) { 9099 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagClose(this); 9100 } 9101 @Override 9102 public void exitRule(ParseTreeListener listener) { 9103 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagClose(this); 9104 } 9105 @Override 9106 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9107 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagClose(this); 9108 else return visitor.visitChildren(this); 9109 } 9110 } 9111 9112 public final OptionTagCloseContext optionTagClose() throws RecognitionException { 9113 OptionTagCloseContext _localctx = new OptionTagCloseContext(_ctx, getState()); 9114 enterRule(_localctx, 80, RULE_optionTagClose); 9115 int _la; 9116 try { 9117 enterOuterAlt(_localctx, 1); 9118 { 9119 setState(1078); 9120 match(OPEN); 9121 setState(1079); 9122 match(SLASH); 9123 setState(1080); 9124 match(OPTION_HTML_TAG_NAME); 9125 setState(1084); 9126 _errHandler.sync(this); 9127 _la = _input.LA(1); 9128 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9129 { 9130 { 9131 setState(1081); 9132 _la = _input.LA(1); 9133 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9134 _errHandler.recoverInline(this); 9135 } else { 9136 consume(); 9137 } 9138 } 9139 } 9140 setState(1086); 9141 _errHandler.sync(this); 9142 _la = _input.LA(1); 9143 } 9144 setState(1087); 9145 match(CLOSE); 9146 } 9147 } 9148 catch (RecognitionException re) { 9149 _localctx.exception = re; 9150 _errHandler.reportError(this, re); 9151 _errHandler.recover(this, re); 9152 } 9153 finally { 9154 exitRule(); 9155 } 9156 return _localctx; 9157 } 9158 9159 public static class OptionContext extends ParserRuleContext { 9160 public OptionTagOpenContext optionTagOpen() { 9161 return getRuleContext(OptionTagOpenContext.class,0); 9162 } 9163 public OptionTagCloseContext optionTagClose() { 9164 return getRuleContext(OptionTagCloseContext.class,0); 9165 } 9166 public List<HtmlTagContext> htmlTag() { 9167 return getRuleContexts(HtmlTagContext.class); 9168 } 9169 public HtmlTagContext htmlTag(int i) { 9170 return getRuleContext(HtmlTagContext.class,i); 9171 } 9172 public List<SingletonTagContext> singletonTag() { 9173 return getRuleContexts(SingletonTagContext.class); 9174 } 9175 public SingletonTagContext singletonTag(int i) { 9176 return getRuleContext(SingletonTagContext.class,i); 9177 } 9178 public List<ParagraphContext> paragraph() { 9179 return getRuleContexts(ParagraphContext.class); 9180 } 9181 public ParagraphContext paragraph(int i) { 9182 return getRuleContext(ParagraphContext.class,i); 9183 } 9184 public List<LiContext> li() { 9185 return getRuleContexts(LiContext.class); 9186 } 9187 public LiContext li(int i) { 9188 return getRuleContext(LiContext.class,i); 9189 } 9190 public List<TrContext> tr() { 9191 return getRuleContexts(TrContext.class); 9192 } 9193 public TrContext tr(int i) { 9194 return getRuleContext(TrContext.class,i); 9195 } 9196 public List<TdContext> td() { 9197 return getRuleContexts(TdContext.class); 9198 } 9199 public TdContext td(int i) { 9200 return getRuleContext(TdContext.class,i); 9201 } 9202 public List<ThContext> th() { 9203 return getRuleContexts(ThContext.class); 9204 } 9205 public ThContext th(int i) { 9206 return getRuleContext(ThContext.class,i); 9207 } 9208 public List<BodyContext> body() { 9209 return getRuleContexts(BodyContext.class); 9210 } 9211 public BodyContext body(int i) { 9212 return getRuleContext(BodyContext.class,i); 9213 } 9214 public List<ColgroupContext> colgroup() { 9215 return getRuleContexts(ColgroupContext.class); 9216 } 9217 public ColgroupContext colgroup(int i) { 9218 return getRuleContext(ColgroupContext.class,i); 9219 } 9220 public List<DdContext> dd() { 9221 return getRuleContexts(DdContext.class); 9222 } 9223 public DdContext dd(int i) { 9224 return getRuleContext(DdContext.class,i); 9225 } 9226 public List<DtContext> dt() { 9227 return getRuleContexts(DtContext.class); 9228 } 9229 public DtContext dt(int i) { 9230 return getRuleContext(DtContext.class,i); 9231 } 9232 public List<HeadContext> head() { 9233 return getRuleContexts(HeadContext.class); 9234 } 9235 public HeadContext head(int i) { 9236 return getRuleContext(HeadContext.class,i); 9237 } 9238 public List<HtmlContext> html() { 9239 return getRuleContexts(HtmlContext.class); 9240 } 9241 public HtmlContext html(int i) { 9242 return getRuleContext(HtmlContext.class,i); 9243 } 9244 public List<TbodyContext> tbody() { 9245 return getRuleContexts(TbodyContext.class); 9246 } 9247 public TbodyContext tbody(int i) { 9248 return getRuleContext(TbodyContext.class,i); 9249 } 9250 public List<TheadContext> thead() { 9251 return getRuleContexts(TheadContext.class); 9252 } 9253 public TheadContext thead(int i) { 9254 return getRuleContext(TheadContext.class,i); 9255 } 9256 public List<TfootContext> tfoot() { 9257 return getRuleContexts(TfootContext.class); 9258 } 9259 public TfootContext tfoot(int i) { 9260 return getRuleContext(TfootContext.class,i); 9261 } 9262 public List<PTagOpenContext> pTagOpen() { 9263 return getRuleContexts(PTagOpenContext.class); 9264 } 9265 public PTagOpenContext pTagOpen(int i) { 9266 return getRuleContext(PTagOpenContext.class,i); 9267 } 9268 public List<LiTagOpenContext> liTagOpen() { 9269 return getRuleContexts(LiTagOpenContext.class); 9270 } 9271 public LiTagOpenContext liTagOpen(int i) { 9272 return getRuleContext(LiTagOpenContext.class,i); 9273 } 9274 public List<TrTagOpenContext> trTagOpen() { 9275 return getRuleContexts(TrTagOpenContext.class); 9276 } 9277 public TrTagOpenContext trTagOpen(int i) { 9278 return getRuleContext(TrTagOpenContext.class,i); 9279 } 9280 public List<TdTagOpenContext> tdTagOpen() { 9281 return getRuleContexts(TdTagOpenContext.class); 9282 } 9283 public TdTagOpenContext tdTagOpen(int i) { 9284 return getRuleContext(TdTagOpenContext.class,i); 9285 } 9286 public List<ThTagOpenContext> thTagOpen() { 9287 return getRuleContexts(ThTagOpenContext.class); 9288 } 9289 public ThTagOpenContext thTagOpen(int i) { 9290 return getRuleContext(ThTagOpenContext.class,i); 9291 } 9292 public List<BodyTagOpenContext> bodyTagOpen() { 9293 return getRuleContexts(BodyTagOpenContext.class); 9294 } 9295 public BodyTagOpenContext bodyTagOpen(int i) { 9296 return getRuleContext(BodyTagOpenContext.class,i); 9297 } 9298 public List<ColgroupTagOpenContext> colgroupTagOpen() { 9299 return getRuleContexts(ColgroupTagOpenContext.class); 9300 } 9301 public ColgroupTagOpenContext colgroupTagOpen(int i) { 9302 return getRuleContext(ColgroupTagOpenContext.class,i); 9303 } 9304 public List<DdTagOpenContext> ddTagOpen() { 9305 return getRuleContexts(DdTagOpenContext.class); 9306 } 9307 public DdTagOpenContext ddTagOpen(int i) { 9308 return getRuleContext(DdTagOpenContext.class,i); 9309 } 9310 public List<DtTagOpenContext> dtTagOpen() { 9311 return getRuleContexts(DtTagOpenContext.class); 9312 } 9313 public DtTagOpenContext dtTagOpen(int i) { 9314 return getRuleContext(DtTagOpenContext.class,i); 9315 } 9316 public List<HeadTagOpenContext> headTagOpen() { 9317 return getRuleContexts(HeadTagOpenContext.class); 9318 } 9319 public HeadTagOpenContext headTagOpen(int i) { 9320 return getRuleContext(HeadTagOpenContext.class,i); 9321 } 9322 public List<HtmlTagOpenContext> htmlTagOpen() { 9323 return getRuleContexts(HtmlTagOpenContext.class); 9324 } 9325 public HtmlTagOpenContext htmlTagOpen(int i) { 9326 return getRuleContext(HtmlTagOpenContext.class,i); 9327 } 9328 public List<TbodyTagOpenContext> tbodyTagOpen() { 9329 return getRuleContexts(TbodyTagOpenContext.class); 9330 } 9331 public TbodyTagOpenContext tbodyTagOpen(int i) { 9332 return getRuleContext(TbodyTagOpenContext.class,i); 9333 } 9334 public List<TheadTagOpenContext> theadTagOpen() { 9335 return getRuleContexts(TheadTagOpenContext.class); 9336 } 9337 public TheadTagOpenContext theadTagOpen(int i) { 9338 return getRuleContext(TheadTagOpenContext.class,i); 9339 } 9340 public List<TfootTagOpenContext> tfootTagOpen() { 9341 return getRuleContexts(TfootTagOpenContext.class); 9342 } 9343 public TfootTagOpenContext tfootTagOpen(int i) { 9344 return getRuleContext(TfootTagOpenContext.class,i); 9345 } 9346 public List<HtmlCommentContext> htmlComment() { 9347 return getRuleContexts(HtmlCommentContext.class); 9348 } 9349 public HtmlCommentContext htmlComment(int i) { 9350 return getRuleContext(HtmlCommentContext.class,i); 9351 } 9352 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 9353 public TerminalNode CDATA(int i) { 9354 return getToken(JavadocParser.CDATA, i); 9355 } 9356 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9357 public TerminalNode NEWLINE(int i) { 9358 return getToken(JavadocParser.NEWLINE, i); 9359 } 9360 public List<TextContext> text() { 9361 return getRuleContexts(TextContext.class); 9362 } 9363 public TextContext text(int i) { 9364 return getRuleContext(TextContext.class,i); 9365 } 9366 public List<JavadocInlineTagContext> javadocInlineTag() { 9367 return getRuleContexts(JavadocInlineTagContext.class); 9368 } 9369 public JavadocInlineTagContext javadocInlineTag(int i) { 9370 return getRuleContext(JavadocInlineTagContext.class,i); 9371 } 9372 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9373 public TerminalNode LEADING_ASTERISK(int i) { 9374 return getToken(JavadocParser.LEADING_ASTERISK, i); 9375 } 9376 public OptionContext(ParserRuleContext parent, int invokingState) { 9377 super(parent, invokingState); 9378 } 9379 @Override public int getRuleIndex() { return RULE_option; } 9380 @Override 9381 public void enterRule(ParseTreeListener listener) { 9382 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOption(this); 9383 } 9384 @Override 9385 public void exitRule(ParseTreeListener listener) { 9386 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOption(this); 9387 } 9388 @Override 9389 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9390 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOption(this); 9391 else return visitor.visitChildren(this); 9392 } 9393 } 9394 9395 public final OptionContext option() throws RecognitionException { 9396 OptionContext _localctx = new OptionContext(_ctx, getState()); 9397 enterRule(_localctx, 82, RULE_option); 9398 try { 9399 int _alt; 9400 enterOuterAlt(_localctx, 1); 9401 { 9402 setState(1089); 9403 optionTagOpen(); 9404 setState(1129); 9405 _errHandler.sync(this); 9406 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 9407 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 9408 if ( _alt==1 ) { 9409 { 9410 setState(1127); 9411 _errHandler.sync(this); 9412 switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { 9413 case 1: 9414 { 9415 setState(1090); 9416 htmlTag(); 9417 } 9418 break; 9419 case 2: 9420 { 9421 setState(1091); 9422 singletonTag(); 9423 } 9424 break; 9425 case 3: 9426 { 9427 setState(1092); 9428 paragraph(); 9429 } 9430 break; 9431 case 4: 9432 { 9433 setState(1093); 9434 li(); 9435 } 9436 break; 9437 case 5: 9438 { 9439 setState(1094); 9440 tr(); 9441 } 9442 break; 9443 case 6: 9444 { 9445 setState(1095); 9446 td(); 9447 } 9448 break; 9449 case 7: 9450 { 9451 setState(1096); 9452 th(); 9453 } 9454 break; 9455 case 8: 9456 { 9457 setState(1097); 9458 body(); 9459 } 9460 break; 9461 case 9: 9462 { 9463 setState(1098); 9464 colgroup(); 9465 } 9466 break; 9467 case 10: 9468 { 9469 setState(1099); 9470 dd(); 9471 } 9472 break; 9473 case 11: 9474 { 9475 setState(1100); 9476 dt(); 9477 } 9478 break; 9479 case 12: 9480 { 9481 setState(1101); 9482 head(); 9483 } 9484 break; 9485 case 13: 9486 { 9487 setState(1102); 9488 html(); 9489 } 9490 break; 9491 case 14: 9492 { 9493 setState(1103); 9494 tbody(); 9495 } 9496 break; 9497 case 15: 9498 { 9499 setState(1104); 9500 thead(); 9501 } 9502 break; 9503 case 16: 9504 { 9505 setState(1105); 9506 tfoot(); 9507 } 9508 break; 9509 case 17: 9510 { 9511 setState(1106); 9512 pTagOpen(); 9513 } 9514 break; 9515 case 18: 9516 { 9517 setState(1107); 9518 liTagOpen(); 9519 } 9520 break; 9521 case 19: 9522 { 9523 setState(1108); 9524 trTagOpen(); 9525 } 9526 break; 9527 case 20: 9528 { 9529 setState(1109); 9530 tdTagOpen(); 9531 } 9532 break; 9533 case 21: 9534 { 9535 setState(1110); 9536 thTagOpen(); 9537 } 9538 break; 9539 case 22: 9540 { 9541 setState(1111); 9542 bodyTagOpen(); 9543 } 9544 break; 9545 case 23: 9546 { 9547 setState(1112); 9548 colgroupTagOpen(); 9549 } 9550 break; 9551 case 24: 9552 { 9553 setState(1113); 9554 ddTagOpen(); 9555 } 9556 break; 9557 case 25: 9558 { 9559 setState(1114); 9560 dtTagOpen(); 9561 } 9562 break; 9563 case 26: 9564 { 9565 setState(1115); 9566 headTagOpen(); 9567 } 9568 break; 9569 case 27: 9570 { 9571 setState(1116); 9572 htmlTagOpen(); 9573 } 9574 break; 9575 case 28: 9576 { 9577 setState(1117); 9578 tbodyTagOpen(); 9579 } 9580 break; 9581 case 29: 9582 { 9583 setState(1118); 9584 theadTagOpen(); 9585 } 9586 break; 9587 case 30: 9588 { 9589 setState(1119); 9590 tfootTagOpen(); 9591 } 9592 break; 9593 case 31: 9594 { 9595 { 9596 setState(1120); 9597 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 9598 setState(1121); 9599 match(LEADING_ASTERISK); 9600 } 9601 } 9602 break; 9603 case 32: 9604 { 9605 setState(1122); 9606 htmlComment(); 9607 } 9608 break; 9609 case 33: 9610 { 9611 setState(1123); 9612 match(CDATA); 9613 } 9614 break; 9615 case 34: 9616 { 9617 setState(1124); 9618 match(NEWLINE); 9619 } 9620 break; 9621 case 35: 9622 { 9623 setState(1125); 9624 text(); 9625 } 9626 break; 9627 case 36: 9628 { 9629 setState(1126); 9630 javadocInlineTag(); 9631 } 9632 break; 9633 } 9634 } 9635 } 9636 setState(1131); 9637 _errHandler.sync(this); 9638 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 9639 } 9640 setState(1132); 9641 optionTagClose(); 9642 } 9643 } 9644 catch (RecognitionException re) { 9645 _localctx.exception = re; 9646 _errHandler.reportError(this, re); 9647 _errHandler.recover(this, re); 9648 } 9649 finally { 9650 exitRule(); 9651 } 9652 return _localctx; 9653 } 9654 9655 public static class TbodyTagOpenContext extends ParserRuleContext { 9656 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9657 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9658 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9659 public List<AttributeContext> attribute() { 9660 return getRuleContexts(AttributeContext.class); 9661 } 9662 public AttributeContext attribute(int i) { 9663 return getRuleContext(AttributeContext.class,i); 9664 } 9665 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9666 public TerminalNode NEWLINE(int i) { 9667 return getToken(JavadocParser.NEWLINE, i); 9668 } 9669 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9670 public TerminalNode LEADING_ASTERISK(int i) { 9671 return getToken(JavadocParser.LEADING_ASTERISK, i); 9672 } 9673 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9674 public TerminalNode WS(int i) { 9675 return getToken(JavadocParser.WS, i); 9676 } 9677 public TbodyTagOpenContext(ParserRuleContext parent, int invokingState) { 9678 super(parent, invokingState); 9679 } 9680 @Override public int getRuleIndex() { return RULE_tbodyTagOpen; } 9681 @Override 9682 public void enterRule(ParseTreeListener listener) { 9683 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagOpen(this); 9684 } 9685 @Override 9686 public void exitRule(ParseTreeListener listener) { 9687 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagOpen(this); 9688 } 9689 @Override 9690 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9691 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagOpen(this); 9692 else return visitor.visitChildren(this); 9693 } 9694 } 9695 9696 public final TbodyTagOpenContext tbodyTagOpen() throws RecognitionException { 9697 TbodyTagOpenContext _localctx = new TbodyTagOpenContext(_ctx, getState()); 9698 enterRule(_localctx, 84, RULE_tbodyTagOpen); 9699 int _la; 9700 try { 9701 enterOuterAlt(_localctx, 1); 9702 { 9703 setState(1134); 9704 match(OPEN); 9705 setState(1135); 9706 match(TBODY_HTML_TAG_NAME); 9707 setState(1142); 9708 _errHandler.sync(this); 9709 _la = _input.LA(1); 9710 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9711 { 9712 setState(1140); 9713 switch (_input.LA(1)) { 9714 case HTML_TAG_NAME: 9715 { 9716 setState(1136); 9717 attribute(); 9718 } 9719 break; 9720 case NEWLINE: 9721 { 9722 setState(1137); 9723 match(NEWLINE); 9724 } 9725 break; 9726 case LEADING_ASTERISK: 9727 { 9728 setState(1138); 9729 match(LEADING_ASTERISK); 9730 } 9731 break; 9732 case WS: 9733 { 9734 setState(1139); 9735 match(WS); 9736 } 9737 break; 9738 default: 9739 throw new NoViableAltException(this); 9740 } 9741 } 9742 setState(1144); 9743 _errHandler.sync(this); 9744 _la = _input.LA(1); 9745 } 9746 setState(1145); 9747 match(CLOSE); 9748 } 9749 } 9750 catch (RecognitionException re) { 9751 _localctx.exception = re; 9752 _errHandler.reportError(this, re); 9753 _errHandler.recover(this, re); 9754 } 9755 finally { 9756 exitRule(); 9757 } 9758 return _localctx; 9759 } 9760 9761 public static class TbodyTagCloseContext extends ParserRuleContext { 9762 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9763 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9764 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9765 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9766 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9767 public TerminalNode NEWLINE(int i) { 9768 return getToken(JavadocParser.NEWLINE, i); 9769 } 9770 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9771 public TerminalNode LEADING_ASTERISK(int i) { 9772 return getToken(JavadocParser.LEADING_ASTERISK, i); 9773 } 9774 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9775 public TerminalNode WS(int i) { 9776 return getToken(JavadocParser.WS, i); 9777 } 9778 public TbodyTagCloseContext(ParserRuleContext parent, int invokingState) { 9779 super(parent, invokingState); 9780 } 9781 @Override public int getRuleIndex() { return RULE_tbodyTagClose; } 9782 @Override 9783 public void enterRule(ParseTreeListener listener) { 9784 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagClose(this); 9785 } 9786 @Override 9787 public void exitRule(ParseTreeListener listener) { 9788 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagClose(this); 9789 } 9790 @Override 9791 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9792 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagClose(this); 9793 else return visitor.visitChildren(this); 9794 } 9795 } 9796 9797 public final TbodyTagCloseContext tbodyTagClose() throws RecognitionException { 9798 TbodyTagCloseContext _localctx = new TbodyTagCloseContext(_ctx, getState()); 9799 enterRule(_localctx, 86, RULE_tbodyTagClose); 9800 int _la; 9801 try { 9802 enterOuterAlt(_localctx, 1); 9803 { 9804 setState(1147); 9805 match(OPEN); 9806 setState(1148); 9807 match(SLASH); 9808 setState(1149); 9809 match(TBODY_HTML_TAG_NAME); 9810 setState(1153); 9811 _errHandler.sync(this); 9812 _la = _input.LA(1); 9813 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9814 { 9815 { 9816 setState(1150); 9817 _la = _input.LA(1); 9818 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9819 _errHandler.recoverInline(this); 9820 } else { 9821 consume(); 9822 } 9823 } 9824 } 9825 setState(1155); 9826 _errHandler.sync(this); 9827 _la = _input.LA(1); 9828 } 9829 setState(1156); 9830 match(CLOSE); 9831 } 9832 } 9833 catch (RecognitionException re) { 9834 _localctx.exception = re; 9835 _errHandler.reportError(this, re); 9836 _errHandler.recover(this, re); 9837 } 9838 finally { 9839 exitRule(); 9840 } 9841 return _localctx; 9842 } 9843 9844 public static class TbodyContext extends ParserRuleContext { 9845 public TbodyTagOpenContext tbodyTagOpen() { 9846 return getRuleContext(TbodyTagOpenContext.class,0); 9847 } 9848 public TbodyTagCloseContext tbodyTagClose() { 9849 return getRuleContext(TbodyTagCloseContext.class,0); 9850 } 9851 public List<HtmlTagContext> htmlTag() { 9852 return getRuleContexts(HtmlTagContext.class); 9853 } 9854 public HtmlTagContext htmlTag(int i) { 9855 return getRuleContext(HtmlTagContext.class,i); 9856 } 9857 public List<SingletonTagContext> singletonTag() { 9858 return getRuleContexts(SingletonTagContext.class); 9859 } 9860 public SingletonTagContext singletonTag(int i) { 9861 return getRuleContext(SingletonTagContext.class,i); 9862 } 9863 public List<ParagraphContext> paragraph() { 9864 return getRuleContexts(ParagraphContext.class); 9865 } 9866 public ParagraphContext paragraph(int i) { 9867 return getRuleContext(ParagraphContext.class,i); 9868 } 9869 public List<LiContext> li() { 9870 return getRuleContexts(LiContext.class); 9871 } 9872 public LiContext li(int i) { 9873 return getRuleContext(LiContext.class,i); 9874 } 9875 public List<TrContext> tr() { 9876 return getRuleContexts(TrContext.class); 9877 } 9878 public TrContext tr(int i) { 9879 return getRuleContext(TrContext.class,i); 9880 } 9881 public List<TdContext> td() { 9882 return getRuleContexts(TdContext.class); 9883 } 9884 public TdContext td(int i) { 9885 return getRuleContext(TdContext.class,i); 9886 } 9887 public List<ThContext> th() { 9888 return getRuleContexts(ThContext.class); 9889 } 9890 public ThContext th(int i) { 9891 return getRuleContext(ThContext.class,i); 9892 } 9893 public List<BodyContext> body() { 9894 return getRuleContexts(BodyContext.class); 9895 } 9896 public BodyContext body(int i) { 9897 return getRuleContext(BodyContext.class,i); 9898 } 9899 public List<ColgroupContext> colgroup() { 9900 return getRuleContexts(ColgroupContext.class); 9901 } 9902 public ColgroupContext colgroup(int i) { 9903 return getRuleContext(ColgroupContext.class,i); 9904 } 9905 public List<DdContext> dd() { 9906 return getRuleContexts(DdContext.class); 9907 } 9908 public DdContext dd(int i) { 9909 return getRuleContext(DdContext.class,i); 9910 } 9911 public List<DtContext> dt() { 9912 return getRuleContexts(DtContext.class); 9913 } 9914 public DtContext dt(int i) { 9915 return getRuleContext(DtContext.class,i); 9916 } 9917 public List<HeadContext> head() { 9918 return getRuleContexts(HeadContext.class); 9919 } 9920 public HeadContext head(int i) { 9921 return getRuleContext(HeadContext.class,i); 9922 } 9923 public List<HtmlContext> html() { 9924 return getRuleContexts(HtmlContext.class); 9925 } 9926 public HtmlContext html(int i) { 9927 return getRuleContext(HtmlContext.class,i); 9928 } 9929 public List<OptionContext> option() { 9930 return getRuleContexts(OptionContext.class); 9931 } 9932 public OptionContext option(int i) { 9933 return getRuleContext(OptionContext.class,i); 9934 } 9935 public List<TheadContext> thead() { 9936 return getRuleContexts(TheadContext.class); 9937 } 9938 public TheadContext thead(int i) { 9939 return getRuleContext(TheadContext.class,i); 9940 } 9941 public List<TfootContext> tfoot() { 9942 return getRuleContexts(TfootContext.class); 9943 } 9944 public TfootContext tfoot(int i) { 9945 return getRuleContext(TfootContext.class,i); 9946 } 9947 public List<PTagOpenContext> pTagOpen() { 9948 return getRuleContexts(PTagOpenContext.class); 9949 } 9950 public PTagOpenContext pTagOpen(int i) { 9951 return getRuleContext(PTagOpenContext.class,i); 9952 } 9953 public List<LiTagOpenContext> liTagOpen() { 9954 return getRuleContexts(LiTagOpenContext.class); 9955 } 9956 public LiTagOpenContext liTagOpen(int i) { 9957 return getRuleContext(LiTagOpenContext.class,i); 9958 } 9959 public List<TrTagOpenContext> trTagOpen() { 9960 return getRuleContexts(TrTagOpenContext.class); 9961 } 9962 public TrTagOpenContext trTagOpen(int i) { 9963 return getRuleContext(TrTagOpenContext.class,i); 9964 } 9965 public List<TdTagOpenContext> tdTagOpen() { 9966 return getRuleContexts(TdTagOpenContext.class); 9967 } 9968 public TdTagOpenContext tdTagOpen(int i) { 9969 return getRuleContext(TdTagOpenContext.class,i); 9970 } 9971 public List<ThTagOpenContext> thTagOpen() { 9972 return getRuleContexts(ThTagOpenContext.class); 9973 } 9974 public ThTagOpenContext thTagOpen(int i) { 9975 return getRuleContext(ThTagOpenContext.class,i); 9976 } 9977 public List<BodyTagOpenContext> bodyTagOpen() { 9978 return getRuleContexts(BodyTagOpenContext.class); 9979 } 9980 public BodyTagOpenContext bodyTagOpen(int i) { 9981 return getRuleContext(BodyTagOpenContext.class,i); 9982 } 9983 public List<ColgroupTagOpenContext> colgroupTagOpen() { 9984 return getRuleContexts(ColgroupTagOpenContext.class); 9985 } 9986 public ColgroupTagOpenContext colgroupTagOpen(int i) { 9987 return getRuleContext(ColgroupTagOpenContext.class,i); 9988 } 9989 public List<DdTagOpenContext> ddTagOpen() { 9990 return getRuleContexts(DdTagOpenContext.class); 9991 } 9992 public DdTagOpenContext ddTagOpen(int i) { 9993 return getRuleContext(DdTagOpenContext.class,i); 9994 } 9995 public List<DtTagOpenContext> dtTagOpen() { 9996 return getRuleContexts(DtTagOpenContext.class); 9997 } 9998 public DtTagOpenContext dtTagOpen(int i) { 9999 return getRuleContext(DtTagOpenContext.class,i); 10000 } 10001 public List<HeadTagOpenContext> headTagOpen() { 10002 return getRuleContexts(HeadTagOpenContext.class); 10003 } 10004 public HeadTagOpenContext headTagOpen(int i) { 10005 return getRuleContext(HeadTagOpenContext.class,i); 10006 } 10007 public List<HtmlTagOpenContext> htmlTagOpen() { 10008 return getRuleContexts(HtmlTagOpenContext.class); 10009 } 10010 public HtmlTagOpenContext htmlTagOpen(int i) { 10011 return getRuleContext(HtmlTagOpenContext.class,i); 10012 } 10013 public List<OptionTagOpenContext> optionTagOpen() { 10014 return getRuleContexts(OptionTagOpenContext.class); 10015 } 10016 public OptionTagOpenContext optionTagOpen(int i) { 10017 return getRuleContext(OptionTagOpenContext.class,i); 10018 } 10019 public List<TheadTagOpenContext> theadTagOpen() { 10020 return getRuleContexts(TheadTagOpenContext.class); 10021 } 10022 public TheadTagOpenContext theadTagOpen(int i) { 10023 return getRuleContext(TheadTagOpenContext.class,i); 10024 } 10025 public List<TfootTagOpenContext> tfootTagOpen() { 10026 return getRuleContexts(TfootTagOpenContext.class); 10027 } 10028 public TfootTagOpenContext tfootTagOpen(int i) { 10029 return getRuleContext(TfootTagOpenContext.class,i); 10030 } 10031 public List<HtmlCommentContext> htmlComment() { 10032 return getRuleContexts(HtmlCommentContext.class); 10033 } 10034 public HtmlCommentContext htmlComment(int i) { 10035 return getRuleContext(HtmlCommentContext.class,i); 10036 } 10037 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10038 public TerminalNode CDATA(int i) { 10039 return getToken(JavadocParser.CDATA, i); 10040 } 10041 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10042 public TerminalNode NEWLINE(int i) { 10043 return getToken(JavadocParser.NEWLINE, i); 10044 } 10045 public List<TextContext> text() { 10046 return getRuleContexts(TextContext.class); 10047 } 10048 public TextContext text(int i) { 10049 return getRuleContext(TextContext.class,i); 10050 } 10051 public List<JavadocInlineTagContext> javadocInlineTag() { 10052 return getRuleContexts(JavadocInlineTagContext.class); 10053 } 10054 public JavadocInlineTagContext javadocInlineTag(int i) { 10055 return getRuleContext(JavadocInlineTagContext.class,i); 10056 } 10057 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10058 public TerminalNode LEADING_ASTERISK(int i) { 10059 return getToken(JavadocParser.LEADING_ASTERISK, i); 10060 } 10061 public TbodyContext(ParserRuleContext parent, int invokingState) { 10062 super(parent, invokingState); 10063 } 10064 @Override public int getRuleIndex() { return RULE_tbody; } 10065 @Override 10066 public void enterRule(ParseTreeListener listener) { 10067 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbody(this); 10068 } 10069 @Override 10070 public void exitRule(ParseTreeListener listener) { 10071 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbody(this); 10072 } 10073 @Override 10074 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10075 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbody(this); 10076 else return visitor.visitChildren(this); 10077 } 10078 } 10079 10080 public final TbodyContext tbody() throws RecognitionException { 10081 TbodyContext _localctx = new TbodyContext(_ctx, getState()); 10082 enterRule(_localctx, 88, RULE_tbody); 10083 try { 10084 int _alt; 10085 enterOuterAlt(_localctx, 1); 10086 { 10087 setState(1158); 10088 tbodyTagOpen(); 10089 setState(1198); 10090 _errHandler.sync(this); 10091 _alt = getInterpreter().adaptivePredict(_input,81,_ctx); 10092 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10093 if ( _alt==1 ) { 10094 { 10095 setState(1196); 10096 _errHandler.sync(this); 10097 switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) { 10098 case 1: 10099 { 10100 setState(1159); 10101 htmlTag(); 10102 } 10103 break; 10104 case 2: 10105 { 10106 setState(1160); 10107 singletonTag(); 10108 } 10109 break; 10110 case 3: 10111 { 10112 setState(1161); 10113 paragraph(); 10114 } 10115 break; 10116 case 4: 10117 { 10118 setState(1162); 10119 li(); 10120 } 10121 break; 10122 case 5: 10123 { 10124 setState(1163); 10125 tr(); 10126 } 10127 break; 10128 case 6: 10129 { 10130 setState(1164); 10131 td(); 10132 } 10133 break; 10134 case 7: 10135 { 10136 setState(1165); 10137 th(); 10138 } 10139 break; 10140 case 8: 10141 { 10142 setState(1166); 10143 body(); 10144 } 10145 break; 10146 case 9: 10147 { 10148 setState(1167); 10149 colgroup(); 10150 } 10151 break; 10152 case 10: 10153 { 10154 setState(1168); 10155 dd(); 10156 } 10157 break; 10158 case 11: 10159 { 10160 setState(1169); 10161 dt(); 10162 } 10163 break; 10164 case 12: 10165 { 10166 setState(1170); 10167 head(); 10168 } 10169 break; 10170 case 13: 10171 { 10172 setState(1171); 10173 html(); 10174 } 10175 break; 10176 case 14: 10177 { 10178 setState(1172); 10179 option(); 10180 } 10181 break; 10182 case 15: 10183 { 10184 setState(1173); 10185 thead(); 10186 } 10187 break; 10188 case 16: 10189 { 10190 setState(1174); 10191 tfoot(); 10192 } 10193 break; 10194 case 17: 10195 { 10196 setState(1175); 10197 pTagOpen(); 10198 } 10199 break; 10200 case 18: 10201 { 10202 setState(1176); 10203 liTagOpen(); 10204 } 10205 break; 10206 case 19: 10207 { 10208 setState(1177); 10209 trTagOpen(); 10210 } 10211 break; 10212 case 20: 10213 { 10214 setState(1178); 10215 tdTagOpen(); 10216 } 10217 break; 10218 case 21: 10219 { 10220 setState(1179); 10221 thTagOpen(); 10222 } 10223 break; 10224 case 22: 10225 { 10226 setState(1180); 10227 bodyTagOpen(); 10228 } 10229 break; 10230 case 23: 10231 { 10232 setState(1181); 10233 colgroupTagOpen(); 10234 } 10235 break; 10236 case 24: 10237 { 10238 setState(1182); 10239 ddTagOpen(); 10240 } 10241 break; 10242 case 25: 10243 { 10244 setState(1183); 10245 dtTagOpen(); 10246 } 10247 break; 10248 case 26: 10249 { 10250 setState(1184); 10251 headTagOpen(); 10252 } 10253 break; 10254 case 27: 10255 { 10256 setState(1185); 10257 htmlTagOpen(); 10258 } 10259 break; 10260 case 28: 10261 { 10262 setState(1186); 10263 optionTagOpen(); 10264 } 10265 break; 10266 case 29: 10267 { 10268 setState(1187); 10269 theadTagOpen(); 10270 } 10271 break; 10272 case 30: 10273 { 10274 setState(1188); 10275 tfootTagOpen(); 10276 } 10277 break; 10278 case 31: 10279 { 10280 { 10281 setState(1189); 10282 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10283 setState(1190); 10284 match(LEADING_ASTERISK); 10285 } 10286 } 10287 break; 10288 case 32: 10289 { 10290 setState(1191); 10291 htmlComment(); 10292 } 10293 break; 10294 case 33: 10295 { 10296 setState(1192); 10297 match(CDATA); 10298 } 10299 break; 10300 case 34: 10301 { 10302 setState(1193); 10303 match(NEWLINE); 10304 } 10305 break; 10306 case 35: 10307 { 10308 setState(1194); 10309 text(); 10310 } 10311 break; 10312 case 36: 10313 { 10314 setState(1195); 10315 javadocInlineTag(); 10316 } 10317 break; 10318 } 10319 } 10320 } 10321 setState(1200); 10322 _errHandler.sync(this); 10323 _alt = getInterpreter().adaptivePredict(_input,81,_ctx); 10324 } 10325 setState(1201); 10326 tbodyTagClose(); 10327 } 10328 } 10329 catch (RecognitionException re) { 10330 _localctx.exception = re; 10331 _errHandler.reportError(this, re); 10332 _errHandler.recover(this, re); 10333 } 10334 finally { 10335 exitRule(); 10336 } 10337 return _localctx; 10338 } 10339 10340 public static class TfootTagOpenContext extends ParserRuleContext { 10341 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10342 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 10343 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10344 public List<AttributeContext> attribute() { 10345 return getRuleContexts(AttributeContext.class); 10346 } 10347 public AttributeContext attribute(int i) { 10348 return getRuleContext(AttributeContext.class,i); 10349 } 10350 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10351 public TerminalNode NEWLINE(int i) { 10352 return getToken(JavadocParser.NEWLINE, i); 10353 } 10354 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10355 public TerminalNode LEADING_ASTERISK(int i) { 10356 return getToken(JavadocParser.LEADING_ASTERISK, i); 10357 } 10358 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10359 public TerminalNode WS(int i) { 10360 return getToken(JavadocParser.WS, i); 10361 } 10362 public TfootTagOpenContext(ParserRuleContext parent, int invokingState) { 10363 super(parent, invokingState); 10364 } 10365 @Override public int getRuleIndex() { return RULE_tfootTagOpen; } 10366 @Override 10367 public void enterRule(ParseTreeListener listener) { 10368 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagOpen(this); 10369 } 10370 @Override 10371 public void exitRule(ParseTreeListener listener) { 10372 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagOpen(this); 10373 } 10374 @Override 10375 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10376 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagOpen(this); 10377 else return visitor.visitChildren(this); 10378 } 10379 } 10380 10381 public final TfootTagOpenContext tfootTagOpen() throws RecognitionException { 10382 TfootTagOpenContext _localctx = new TfootTagOpenContext(_ctx, getState()); 10383 enterRule(_localctx, 90, RULE_tfootTagOpen); 10384 int _la; 10385 try { 10386 enterOuterAlt(_localctx, 1); 10387 { 10388 setState(1203); 10389 match(OPEN); 10390 setState(1204); 10391 match(TFOOT_HTML_TAG_NAME); 10392 setState(1211); 10393 _errHandler.sync(this); 10394 _la = _input.LA(1); 10395 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 10396 { 10397 setState(1209); 10398 switch (_input.LA(1)) { 10399 case HTML_TAG_NAME: 10400 { 10401 setState(1205); 10402 attribute(); 10403 } 10404 break; 10405 case NEWLINE: 10406 { 10407 setState(1206); 10408 match(NEWLINE); 10409 } 10410 break; 10411 case LEADING_ASTERISK: 10412 { 10413 setState(1207); 10414 match(LEADING_ASTERISK); 10415 } 10416 break; 10417 case WS: 10418 { 10419 setState(1208); 10420 match(WS); 10421 } 10422 break; 10423 default: 10424 throw new NoViableAltException(this); 10425 } 10426 } 10427 setState(1213); 10428 _errHandler.sync(this); 10429 _la = _input.LA(1); 10430 } 10431 setState(1214); 10432 match(CLOSE); 10433 } 10434 } 10435 catch (RecognitionException re) { 10436 _localctx.exception = re; 10437 _errHandler.reportError(this, re); 10438 _errHandler.recover(this, re); 10439 } 10440 finally { 10441 exitRule(); 10442 } 10443 return _localctx; 10444 } 10445 10446 public static class TfootTagCloseContext extends ParserRuleContext { 10447 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10448 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 10449 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 10450 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10451 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10452 public TerminalNode NEWLINE(int i) { 10453 return getToken(JavadocParser.NEWLINE, i); 10454 } 10455 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10456 public TerminalNode LEADING_ASTERISK(int i) { 10457 return getToken(JavadocParser.LEADING_ASTERISK, i); 10458 } 10459 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10460 public TerminalNode WS(int i) { 10461 return getToken(JavadocParser.WS, i); 10462 } 10463 public TfootTagCloseContext(ParserRuleContext parent, int invokingState) { 10464 super(parent, invokingState); 10465 } 10466 @Override public int getRuleIndex() { return RULE_tfootTagClose; } 10467 @Override 10468 public void enterRule(ParseTreeListener listener) { 10469 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagClose(this); 10470 } 10471 @Override 10472 public void exitRule(ParseTreeListener listener) { 10473 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagClose(this); 10474 } 10475 @Override 10476 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10477 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagClose(this); 10478 else return visitor.visitChildren(this); 10479 } 10480 } 10481 10482 public final TfootTagCloseContext tfootTagClose() throws RecognitionException { 10483 TfootTagCloseContext _localctx = new TfootTagCloseContext(_ctx, getState()); 10484 enterRule(_localctx, 92, RULE_tfootTagClose); 10485 int _la; 10486 try { 10487 enterOuterAlt(_localctx, 1); 10488 { 10489 setState(1216); 10490 match(OPEN); 10491 setState(1217); 10492 match(SLASH); 10493 setState(1218); 10494 match(TFOOT_HTML_TAG_NAME); 10495 setState(1222); 10496 _errHandler.sync(this); 10497 _la = _input.LA(1); 10498 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10499 { 10500 { 10501 setState(1219); 10502 _la = _input.LA(1); 10503 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10504 _errHandler.recoverInline(this); 10505 } else { 10506 consume(); 10507 } 10508 } 10509 } 10510 setState(1224); 10511 _errHandler.sync(this); 10512 _la = _input.LA(1); 10513 } 10514 setState(1225); 10515 match(CLOSE); 10516 } 10517 } 10518 catch (RecognitionException re) { 10519 _localctx.exception = re; 10520 _errHandler.reportError(this, re); 10521 _errHandler.recover(this, re); 10522 } 10523 finally { 10524 exitRule(); 10525 } 10526 return _localctx; 10527 } 10528 10529 public static class TfootContext extends ParserRuleContext { 10530 public TfootTagOpenContext tfootTagOpen() { 10531 return getRuleContext(TfootTagOpenContext.class,0); 10532 } 10533 public TfootTagCloseContext tfootTagClose() { 10534 return getRuleContext(TfootTagCloseContext.class,0); 10535 } 10536 public List<HtmlTagContext> htmlTag() { 10537 return getRuleContexts(HtmlTagContext.class); 10538 } 10539 public HtmlTagContext htmlTag(int i) { 10540 return getRuleContext(HtmlTagContext.class,i); 10541 } 10542 public List<SingletonTagContext> singletonTag() { 10543 return getRuleContexts(SingletonTagContext.class); 10544 } 10545 public SingletonTagContext singletonTag(int i) { 10546 return getRuleContext(SingletonTagContext.class,i); 10547 } 10548 public List<ParagraphContext> paragraph() { 10549 return getRuleContexts(ParagraphContext.class); 10550 } 10551 public ParagraphContext paragraph(int i) { 10552 return getRuleContext(ParagraphContext.class,i); 10553 } 10554 public List<LiContext> li() { 10555 return getRuleContexts(LiContext.class); 10556 } 10557 public LiContext li(int i) { 10558 return getRuleContext(LiContext.class,i); 10559 } 10560 public List<TrContext> tr() { 10561 return getRuleContexts(TrContext.class); 10562 } 10563 public TrContext tr(int i) { 10564 return getRuleContext(TrContext.class,i); 10565 } 10566 public List<TdContext> td() { 10567 return getRuleContexts(TdContext.class); 10568 } 10569 public TdContext td(int i) { 10570 return getRuleContext(TdContext.class,i); 10571 } 10572 public List<ThContext> th() { 10573 return getRuleContexts(ThContext.class); 10574 } 10575 public ThContext th(int i) { 10576 return getRuleContext(ThContext.class,i); 10577 } 10578 public List<BodyContext> body() { 10579 return getRuleContexts(BodyContext.class); 10580 } 10581 public BodyContext body(int i) { 10582 return getRuleContext(BodyContext.class,i); 10583 } 10584 public List<ColgroupContext> colgroup() { 10585 return getRuleContexts(ColgroupContext.class); 10586 } 10587 public ColgroupContext colgroup(int i) { 10588 return getRuleContext(ColgroupContext.class,i); 10589 } 10590 public List<DdContext> dd() { 10591 return getRuleContexts(DdContext.class); 10592 } 10593 public DdContext dd(int i) { 10594 return getRuleContext(DdContext.class,i); 10595 } 10596 public List<DtContext> dt() { 10597 return getRuleContexts(DtContext.class); 10598 } 10599 public DtContext dt(int i) { 10600 return getRuleContext(DtContext.class,i); 10601 } 10602 public List<HeadContext> head() { 10603 return getRuleContexts(HeadContext.class); 10604 } 10605 public HeadContext head(int i) { 10606 return getRuleContext(HeadContext.class,i); 10607 } 10608 public List<HtmlContext> html() { 10609 return getRuleContexts(HtmlContext.class); 10610 } 10611 public HtmlContext html(int i) { 10612 return getRuleContext(HtmlContext.class,i); 10613 } 10614 public List<OptionContext> option() { 10615 return getRuleContexts(OptionContext.class); 10616 } 10617 public OptionContext option(int i) { 10618 return getRuleContext(OptionContext.class,i); 10619 } 10620 public List<TbodyContext> tbody() { 10621 return getRuleContexts(TbodyContext.class); 10622 } 10623 public TbodyContext tbody(int i) { 10624 return getRuleContext(TbodyContext.class,i); 10625 } 10626 public List<TheadContext> thead() { 10627 return getRuleContexts(TheadContext.class); 10628 } 10629 public TheadContext thead(int i) { 10630 return getRuleContext(TheadContext.class,i); 10631 } 10632 public List<PTagOpenContext> pTagOpen() { 10633 return getRuleContexts(PTagOpenContext.class); 10634 } 10635 public PTagOpenContext pTagOpen(int i) { 10636 return getRuleContext(PTagOpenContext.class,i); 10637 } 10638 public List<LiTagOpenContext> liTagOpen() { 10639 return getRuleContexts(LiTagOpenContext.class); 10640 } 10641 public LiTagOpenContext liTagOpen(int i) { 10642 return getRuleContext(LiTagOpenContext.class,i); 10643 } 10644 public List<TrTagOpenContext> trTagOpen() { 10645 return getRuleContexts(TrTagOpenContext.class); 10646 } 10647 public TrTagOpenContext trTagOpen(int i) { 10648 return getRuleContext(TrTagOpenContext.class,i); 10649 } 10650 public List<TdTagOpenContext> tdTagOpen() { 10651 return getRuleContexts(TdTagOpenContext.class); 10652 } 10653 public TdTagOpenContext tdTagOpen(int i) { 10654 return getRuleContext(TdTagOpenContext.class,i); 10655 } 10656 public List<ThTagOpenContext> thTagOpen() { 10657 return getRuleContexts(ThTagOpenContext.class); 10658 } 10659 public ThTagOpenContext thTagOpen(int i) { 10660 return getRuleContext(ThTagOpenContext.class,i); 10661 } 10662 public List<BodyTagOpenContext> bodyTagOpen() { 10663 return getRuleContexts(BodyTagOpenContext.class); 10664 } 10665 public BodyTagOpenContext bodyTagOpen(int i) { 10666 return getRuleContext(BodyTagOpenContext.class,i); 10667 } 10668 public List<ColgroupTagOpenContext> colgroupTagOpen() { 10669 return getRuleContexts(ColgroupTagOpenContext.class); 10670 } 10671 public ColgroupTagOpenContext colgroupTagOpen(int i) { 10672 return getRuleContext(ColgroupTagOpenContext.class,i); 10673 } 10674 public List<DdTagOpenContext> ddTagOpen() { 10675 return getRuleContexts(DdTagOpenContext.class); 10676 } 10677 public DdTagOpenContext ddTagOpen(int i) { 10678 return getRuleContext(DdTagOpenContext.class,i); 10679 } 10680 public List<DtTagOpenContext> dtTagOpen() { 10681 return getRuleContexts(DtTagOpenContext.class); 10682 } 10683 public DtTagOpenContext dtTagOpen(int i) { 10684 return getRuleContext(DtTagOpenContext.class,i); 10685 } 10686 public List<HeadTagOpenContext> headTagOpen() { 10687 return getRuleContexts(HeadTagOpenContext.class); 10688 } 10689 public HeadTagOpenContext headTagOpen(int i) { 10690 return getRuleContext(HeadTagOpenContext.class,i); 10691 } 10692 public List<HtmlTagOpenContext> htmlTagOpen() { 10693 return getRuleContexts(HtmlTagOpenContext.class); 10694 } 10695 public HtmlTagOpenContext htmlTagOpen(int i) { 10696 return getRuleContext(HtmlTagOpenContext.class,i); 10697 } 10698 public List<OptionTagOpenContext> optionTagOpen() { 10699 return getRuleContexts(OptionTagOpenContext.class); 10700 } 10701 public OptionTagOpenContext optionTagOpen(int i) { 10702 return getRuleContext(OptionTagOpenContext.class,i); 10703 } 10704 public List<TbodyTagOpenContext> tbodyTagOpen() { 10705 return getRuleContexts(TbodyTagOpenContext.class); 10706 } 10707 public TbodyTagOpenContext tbodyTagOpen(int i) { 10708 return getRuleContext(TbodyTagOpenContext.class,i); 10709 } 10710 public List<TheadTagOpenContext> theadTagOpen() { 10711 return getRuleContexts(TheadTagOpenContext.class); 10712 } 10713 public TheadTagOpenContext theadTagOpen(int i) { 10714 return getRuleContext(TheadTagOpenContext.class,i); 10715 } 10716 public List<HtmlCommentContext> htmlComment() { 10717 return getRuleContexts(HtmlCommentContext.class); 10718 } 10719 public HtmlCommentContext htmlComment(int i) { 10720 return getRuleContext(HtmlCommentContext.class,i); 10721 } 10722 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10723 public TerminalNode CDATA(int i) { 10724 return getToken(JavadocParser.CDATA, i); 10725 } 10726 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10727 public TerminalNode NEWLINE(int i) { 10728 return getToken(JavadocParser.NEWLINE, i); 10729 } 10730 public List<TextContext> text() { 10731 return getRuleContexts(TextContext.class); 10732 } 10733 public TextContext text(int i) { 10734 return getRuleContext(TextContext.class,i); 10735 } 10736 public List<JavadocInlineTagContext> javadocInlineTag() { 10737 return getRuleContexts(JavadocInlineTagContext.class); 10738 } 10739 public JavadocInlineTagContext javadocInlineTag(int i) { 10740 return getRuleContext(JavadocInlineTagContext.class,i); 10741 } 10742 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10743 public TerminalNode LEADING_ASTERISK(int i) { 10744 return getToken(JavadocParser.LEADING_ASTERISK, i); 10745 } 10746 public TfootContext(ParserRuleContext parent, int invokingState) { 10747 super(parent, invokingState); 10748 } 10749 @Override public int getRuleIndex() { return RULE_tfoot; } 10750 @Override 10751 public void enterRule(ParseTreeListener listener) { 10752 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfoot(this); 10753 } 10754 @Override 10755 public void exitRule(ParseTreeListener listener) { 10756 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfoot(this); 10757 } 10758 @Override 10759 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10760 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfoot(this); 10761 else return visitor.visitChildren(this); 10762 } 10763 } 10764 10765 public final TfootContext tfoot() throws RecognitionException { 10766 TfootContext _localctx = new TfootContext(_ctx, getState()); 10767 enterRule(_localctx, 94, RULE_tfoot); 10768 try { 10769 int _alt; 10770 enterOuterAlt(_localctx, 1); 10771 { 10772 setState(1227); 10773 tfootTagOpen(); 10774 setState(1267); 10775 _errHandler.sync(this); 10776 _alt = getInterpreter().adaptivePredict(_input,86,_ctx); 10777 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10778 if ( _alt==1 ) { 10779 { 10780 setState(1265); 10781 _errHandler.sync(this); 10782 switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) { 10783 case 1: 10784 { 10785 setState(1228); 10786 htmlTag(); 10787 } 10788 break; 10789 case 2: 10790 { 10791 setState(1229); 10792 singletonTag(); 10793 } 10794 break; 10795 case 3: 10796 { 10797 setState(1230); 10798 paragraph(); 10799 } 10800 break; 10801 case 4: 10802 { 10803 setState(1231); 10804 li(); 10805 } 10806 break; 10807 case 5: 10808 { 10809 setState(1232); 10810 tr(); 10811 } 10812 break; 10813 case 6: 10814 { 10815 setState(1233); 10816 td(); 10817 } 10818 break; 10819 case 7: 10820 { 10821 setState(1234); 10822 th(); 10823 } 10824 break; 10825 case 8: 10826 { 10827 setState(1235); 10828 body(); 10829 } 10830 break; 10831 case 9: 10832 { 10833 setState(1236); 10834 colgroup(); 10835 } 10836 break; 10837 case 10: 10838 { 10839 setState(1237); 10840 dd(); 10841 } 10842 break; 10843 case 11: 10844 { 10845 setState(1238); 10846 dt(); 10847 } 10848 break; 10849 case 12: 10850 { 10851 setState(1239); 10852 head(); 10853 } 10854 break; 10855 case 13: 10856 { 10857 setState(1240); 10858 html(); 10859 } 10860 break; 10861 case 14: 10862 { 10863 setState(1241); 10864 option(); 10865 } 10866 break; 10867 case 15: 10868 { 10869 setState(1242); 10870 tbody(); 10871 } 10872 break; 10873 case 16: 10874 { 10875 setState(1243); 10876 thead(); 10877 } 10878 break; 10879 case 17: 10880 { 10881 setState(1244); 10882 pTagOpen(); 10883 } 10884 break; 10885 case 18: 10886 { 10887 setState(1245); 10888 liTagOpen(); 10889 } 10890 break; 10891 case 19: 10892 { 10893 setState(1246); 10894 trTagOpen(); 10895 } 10896 break; 10897 case 20: 10898 { 10899 setState(1247); 10900 tdTagOpen(); 10901 } 10902 break; 10903 case 21: 10904 { 10905 setState(1248); 10906 thTagOpen(); 10907 } 10908 break; 10909 case 22: 10910 { 10911 setState(1249); 10912 bodyTagOpen(); 10913 } 10914 break; 10915 case 23: 10916 { 10917 setState(1250); 10918 colgroupTagOpen(); 10919 } 10920 break; 10921 case 24: 10922 { 10923 setState(1251); 10924 ddTagOpen(); 10925 } 10926 break; 10927 case 25: 10928 { 10929 setState(1252); 10930 dtTagOpen(); 10931 } 10932 break; 10933 case 26: 10934 { 10935 setState(1253); 10936 headTagOpen(); 10937 } 10938 break; 10939 case 27: 10940 { 10941 setState(1254); 10942 htmlTagOpen(); 10943 } 10944 break; 10945 case 28: 10946 { 10947 setState(1255); 10948 optionTagOpen(); 10949 } 10950 break; 10951 case 29: 10952 { 10953 setState(1256); 10954 tbodyTagOpen(); 10955 } 10956 break; 10957 case 30: 10958 { 10959 setState(1257); 10960 theadTagOpen(); 10961 } 10962 break; 10963 case 31: 10964 { 10965 { 10966 setState(1258); 10967 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10968 setState(1259); 10969 match(LEADING_ASTERISK); 10970 } 10971 } 10972 break; 10973 case 32: 10974 { 10975 setState(1260); 10976 htmlComment(); 10977 } 10978 break; 10979 case 33: 10980 { 10981 setState(1261); 10982 match(CDATA); 10983 } 10984 break; 10985 case 34: 10986 { 10987 setState(1262); 10988 match(NEWLINE); 10989 } 10990 break; 10991 case 35: 10992 { 10993 setState(1263); 10994 text(); 10995 } 10996 break; 10997 case 36: 10998 { 10999 setState(1264); 11000 javadocInlineTag(); 11001 } 11002 break; 11003 } 11004 } 11005 } 11006 setState(1269); 11007 _errHandler.sync(this); 11008 _alt = getInterpreter().adaptivePredict(_input,86,_ctx); 11009 } 11010 setState(1270); 11011 tfootTagClose(); 11012 } 11013 } 11014 catch (RecognitionException re) { 11015 _localctx.exception = re; 11016 _errHandler.reportError(this, re); 11017 _errHandler.recover(this, re); 11018 } 11019 finally { 11020 exitRule(); 11021 } 11022 return _localctx; 11023 } 11024 11025 public static class TheadTagOpenContext extends ParserRuleContext { 11026 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11027 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11028 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11029 public List<AttributeContext> attribute() { 11030 return getRuleContexts(AttributeContext.class); 11031 } 11032 public AttributeContext attribute(int i) { 11033 return getRuleContext(AttributeContext.class,i); 11034 } 11035 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11036 public TerminalNode NEWLINE(int i) { 11037 return getToken(JavadocParser.NEWLINE, i); 11038 } 11039 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11040 public TerminalNode LEADING_ASTERISK(int i) { 11041 return getToken(JavadocParser.LEADING_ASTERISK, i); 11042 } 11043 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11044 public TerminalNode WS(int i) { 11045 return getToken(JavadocParser.WS, i); 11046 } 11047 public TheadTagOpenContext(ParserRuleContext parent, int invokingState) { 11048 super(parent, invokingState); 11049 } 11050 @Override public int getRuleIndex() { return RULE_theadTagOpen; } 11051 @Override 11052 public void enterRule(ParseTreeListener listener) { 11053 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagOpen(this); 11054 } 11055 @Override 11056 public void exitRule(ParseTreeListener listener) { 11057 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagOpen(this); 11058 } 11059 @Override 11060 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11061 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagOpen(this); 11062 else return visitor.visitChildren(this); 11063 } 11064 } 11065 11066 public final TheadTagOpenContext theadTagOpen() throws RecognitionException { 11067 TheadTagOpenContext _localctx = new TheadTagOpenContext(_ctx, getState()); 11068 enterRule(_localctx, 96, RULE_theadTagOpen); 11069 int _la; 11070 try { 11071 enterOuterAlt(_localctx, 1); 11072 { 11073 setState(1272); 11074 match(OPEN); 11075 setState(1273); 11076 match(THEAD_HTML_TAG_NAME); 11077 setState(1280); 11078 _errHandler.sync(this); 11079 _la = _input.LA(1); 11080 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11081 { 11082 setState(1278); 11083 switch (_input.LA(1)) { 11084 case HTML_TAG_NAME: 11085 { 11086 setState(1274); 11087 attribute(); 11088 } 11089 break; 11090 case NEWLINE: 11091 { 11092 setState(1275); 11093 match(NEWLINE); 11094 } 11095 break; 11096 case LEADING_ASTERISK: 11097 { 11098 setState(1276); 11099 match(LEADING_ASTERISK); 11100 } 11101 break; 11102 case WS: 11103 { 11104 setState(1277); 11105 match(WS); 11106 } 11107 break; 11108 default: 11109 throw new NoViableAltException(this); 11110 } 11111 } 11112 setState(1282); 11113 _errHandler.sync(this); 11114 _la = _input.LA(1); 11115 } 11116 setState(1283); 11117 match(CLOSE); 11118 } 11119 } 11120 catch (RecognitionException re) { 11121 _localctx.exception = re; 11122 _errHandler.reportError(this, re); 11123 _errHandler.recover(this, re); 11124 } 11125 finally { 11126 exitRule(); 11127 } 11128 return _localctx; 11129 } 11130 11131 public static class TheadTagCloseContext extends ParserRuleContext { 11132 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11133 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 11134 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11135 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11136 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11137 public TerminalNode NEWLINE(int i) { 11138 return getToken(JavadocParser.NEWLINE, i); 11139 } 11140 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11141 public TerminalNode LEADING_ASTERISK(int i) { 11142 return getToken(JavadocParser.LEADING_ASTERISK, i); 11143 } 11144 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11145 public TerminalNode WS(int i) { 11146 return getToken(JavadocParser.WS, i); 11147 } 11148 public TheadTagCloseContext(ParserRuleContext parent, int invokingState) { 11149 super(parent, invokingState); 11150 } 11151 @Override public int getRuleIndex() { return RULE_theadTagClose; } 11152 @Override 11153 public void enterRule(ParseTreeListener listener) { 11154 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagClose(this); 11155 } 11156 @Override 11157 public void exitRule(ParseTreeListener listener) { 11158 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagClose(this); 11159 } 11160 @Override 11161 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11162 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagClose(this); 11163 else return visitor.visitChildren(this); 11164 } 11165 } 11166 11167 public final TheadTagCloseContext theadTagClose() throws RecognitionException { 11168 TheadTagCloseContext _localctx = new TheadTagCloseContext(_ctx, getState()); 11169 enterRule(_localctx, 98, RULE_theadTagClose); 11170 int _la; 11171 try { 11172 enterOuterAlt(_localctx, 1); 11173 { 11174 setState(1285); 11175 match(OPEN); 11176 setState(1286); 11177 match(SLASH); 11178 setState(1287); 11179 match(THEAD_HTML_TAG_NAME); 11180 setState(1291); 11181 _errHandler.sync(this); 11182 _la = _input.LA(1); 11183 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 11184 { 11185 { 11186 setState(1288); 11187 _la = _input.LA(1); 11188 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 11189 _errHandler.recoverInline(this); 11190 } else { 11191 consume(); 11192 } 11193 } 11194 } 11195 setState(1293); 11196 _errHandler.sync(this); 11197 _la = _input.LA(1); 11198 } 11199 setState(1294); 11200 match(CLOSE); 11201 } 11202 } 11203 catch (RecognitionException re) { 11204 _localctx.exception = re; 11205 _errHandler.reportError(this, re); 11206 _errHandler.recover(this, re); 11207 } 11208 finally { 11209 exitRule(); 11210 } 11211 return _localctx; 11212 } 11213 11214 public static class TheadContext extends ParserRuleContext { 11215 public TheadTagOpenContext theadTagOpen() { 11216 return getRuleContext(TheadTagOpenContext.class,0); 11217 } 11218 public TheadTagCloseContext theadTagClose() { 11219 return getRuleContext(TheadTagCloseContext.class,0); 11220 } 11221 public List<HtmlTagContext> htmlTag() { 11222 return getRuleContexts(HtmlTagContext.class); 11223 } 11224 public HtmlTagContext htmlTag(int i) { 11225 return getRuleContext(HtmlTagContext.class,i); 11226 } 11227 public List<SingletonTagContext> singletonTag() { 11228 return getRuleContexts(SingletonTagContext.class); 11229 } 11230 public SingletonTagContext singletonTag(int i) { 11231 return getRuleContext(SingletonTagContext.class,i); 11232 } 11233 public List<ParagraphContext> paragraph() { 11234 return getRuleContexts(ParagraphContext.class); 11235 } 11236 public ParagraphContext paragraph(int i) { 11237 return getRuleContext(ParagraphContext.class,i); 11238 } 11239 public List<LiContext> li() { 11240 return getRuleContexts(LiContext.class); 11241 } 11242 public LiContext li(int i) { 11243 return getRuleContext(LiContext.class,i); 11244 } 11245 public List<TrContext> tr() { 11246 return getRuleContexts(TrContext.class); 11247 } 11248 public TrContext tr(int i) { 11249 return getRuleContext(TrContext.class,i); 11250 } 11251 public List<TdContext> td() { 11252 return getRuleContexts(TdContext.class); 11253 } 11254 public TdContext td(int i) { 11255 return getRuleContext(TdContext.class,i); 11256 } 11257 public List<ThContext> th() { 11258 return getRuleContexts(ThContext.class); 11259 } 11260 public ThContext th(int i) { 11261 return getRuleContext(ThContext.class,i); 11262 } 11263 public List<BodyContext> body() { 11264 return getRuleContexts(BodyContext.class); 11265 } 11266 public BodyContext body(int i) { 11267 return getRuleContext(BodyContext.class,i); 11268 } 11269 public List<ColgroupContext> colgroup() { 11270 return getRuleContexts(ColgroupContext.class); 11271 } 11272 public ColgroupContext colgroup(int i) { 11273 return getRuleContext(ColgroupContext.class,i); 11274 } 11275 public List<DdContext> dd() { 11276 return getRuleContexts(DdContext.class); 11277 } 11278 public DdContext dd(int i) { 11279 return getRuleContext(DdContext.class,i); 11280 } 11281 public List<DtContext> dt() { 11282 return getRuleContexts(DtContext.class); 11283 } 11284 public DtContext dt(int i) { 11285 return getRuleContext(DtContext.class,i); 11286 } 11287 public List<HeadContext> head() { 11288 return getRuleContexts(HeadContext.class); 11289 } 11290 public HeadContext head(int i) { 11291 return getRuleContext(HeadContext.class,i); 11292 } 11293 public List<HtmlContext> html() { 11294 return getRuleContexts(HtmlContext.class); 11295 } 11296 public HtmlContext html(int i) { 11297 return getRuleContext(HtmlContext.class,i); 11298 } 11299 public List<OptionContext> option() { 11300 return getRuleContexts(OptionContext.class); 11301 } 11302 public OptionContext option(int i) { 11303 return getRuleContext(OptionContext.class,i); 11304 } 11305 public List<TbodyContext> tbody() { 11306 return getRuleContexts(TbodyContext.class); 11307 } 11308 public TbodyContext tbody(int i) { 11309 return getRuleContext(TbodyContext.class,i); 11310 } 11311 public List<TfootContext> tfoot() { 11312 return getRuleContexts(TfootContext.class); 11313 } 11314 public TfootContext tfoot(int i) { 11315 return getRuleContext(TfootContext.class,i); 11316 } 11317 public List<PTagOpenContext> pTagOpen() { 11318 return getRuleContexts(PTagOpenContext.class); 11319 } 11320 public PTagOpenContext pTagOpen(int i) { 11321 return getRuleContext(PTagOpenContext.class,i); 11322 } 11323 public List<LiTagOpenContext> liTagOpen() { 11324 return getRuleContexts(LiTagOpenContext.class); 11325 } 11326 public LiTagOpenContext liTagOpen(int i) { 11327 return getRuleContext(LiTagOpenContext.class,i); 11328 } 11329 public List<TrTagOpenContext> trTagOpen() { 11330 return getRuleContexts(TrTagOpenContext.class); 11331 } 11332 public TrTagOpenContext trTagOpen(int i) { 11333 return getRuleContext(TrTagOpenContext.class,i); 11334 } 11335 public List<TdTagOpenContext> tdTagOpen() { 11336 return getRuleContexts(TdTagOpenContext.class); 11337 } 11338 public TdTagOpenContext tdTagOpen(int i) { 11339 return getRuleContext(TdTagOpenContext.class,i); 11340 } 11341 public List<ThTagOpenContext> thTagOpen() { 11342 return getRuleContexts(ThTagOpenContext.class); 11343 } 11344 public ThTagOpenContext thTagOpen(int i) { 11345 return getRuleContext(ThTagOpenContext.class,i); 11346 } 11347 public List<BodyTagOpenContext> bodyTagOpen() { 11348 return getRuleContexts(BodyTagOpenContext.class); 11349 } 11350 public BodyTagOpenContext bodyTagOpen(int i) { 11351 return getRuleContext(BodyTagOpenContext.class,i); 11352 } 11353 public List<ColgroupTagOpenContext> colgroupTagOpen() { 11354 return getRuleContexts(ColgroupTagOpenContext.class); 11355 } 11356 public ColgroupTagOpenContext colgroupTagOpen(int i) { 11357 return getRuleContext(ColgroupTagOpenContext.class,i); 11358 } 11359 public List<DdTagOpenContext> ddTagOpen() { 11360 return getRuleContexts(DdTagOpenContext.class); 11361 } 11362 public DdTagOpenContext ddTagOpen(int i) { 11363 return getRuleContext(DdTagOpenContext.class,i); 11364 } 11365 public List<DtTagOpenContext> dtTagOpen() { 11366 return getRuleContexts(DtTagOpenContext.class); 11367 } 11368 public DtTagOpenContext dtTagOpen(int i) { 11369 return getRuleContext(DtTagOpenContext.class,i); 11370 } 11371 public List<HeadTagOpenContext> headTagOpen() { 11372 return getRuleContexts(HeadTagOpenContext.class); 11373 } 11374 public HeadTagOpenContext headTagOpen(int i) { 11375 return getRuleContext(HeadTagOpenContext.class,i); 11376 } 11377 public List<HtmlTagOpenContext> htmlTagOpen() { 11378 return getRuleContexts(HtmlTagOpenContext.class); 11379 } 11380 public HtmlTagOpenContext htmlTagOpen(int i) { 11381 return getRuleContext(HtmlTagOpenContext.class,i); 11382 } 11383 public List<OptionTagOpenContext> optionTagOpen() { 11384 return getRuleContexts(OptionTagOpenContext.class); 11385 } 11386 public OptionTagOpenContext optionTagOpen(int i) { 11387 return getRuleContext(OptionTagOpenContext.class,i); 11388 } 11389 public List<TbodyTagOpenContext> tbodyTagOpen() { 11390 return getRuleContexts(TbodyTagOpenContext.class); 11391 } 11392 public TbodyTagOpenContext tbodyTagOpen(int i) { 11393 return getRuleContext(TbodyTagOpenContext.class,i); 11394 } 11395 public List<TfootTagOpenContext> tfootTagOpen() { 11396 return getRuleContexts(TfootTagOpenContext.class); 11397 } 11398 public TfootTagOpenContext tfootTagOpen(int i) { 11399 return getRuleContext(TfootTagOpenContext.class,i); 11400 } 11401 public List<HtmlCommentContext> htmlComment() { 11402 return getRuleContexts(HtmlCommentContext.class); 11403 } 11404 public HtmlCommentContext htmlComment(int i) { 11405 return getRuleContext(HtmlCommentContext.class,i); 11406 } 11407 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 11408 public TerminalNode CDATA(int i) { 11409 return getToken(JavadocParser.CDATA, i); 11410 } 11411 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11412 public TerminalNode NEWLINE(int i) { 11413 return getToken(JavadocParser.NEWLINE, i); 11414 } 11415 public List<TextContext> text() { 11416 return getRuleContexts(TextContext.class); 11417 } 11418 public TextContext text(int i) { 11419 return getRuleContext(TextContext.class,i); 11420 } 11421 public List<JavadocInlineTagContext> javadocInlineTag() { 11422 return getRuleContexts(JavadocInlineTagContext.class); 11423 } 11424 public JavadocInlineTagContext javadocInlineTag(int i) { 11425 return getRuleContext(JavadocInlineTagContext.class,i); 11426 } 11427 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11428 public TerminalNode LEADING_ASTERISK(int i) { 11429 return getToken(JavadocParser.LEADING_ASTERISK, i); 11430 } 11431 public TheadContext(ParserRuleContext parent, int invokingState) { 11432 super(parent, invokingState); 11433 } 11434 @Override public int getRuleIndex() { return RULE_thead; } 11435 @Override 11436 public void enterRule(ParseTreeListener listener) { 11437 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThead(this); 11438 } 11439 @Override 11440 public void exitRule(ParseTreeListener listener) { 11441 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThead(this); 11442 } 11443 @Override 11444 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11445 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThead(this); 11446 else return visitor.visitChildren(this); 11447 } 11448 } 11449 11450 public final TheadContext thead() throws RecognitionException { 11451 TheadContext _localctx = new TheadContext(_ctx, getState()); 11452 enterRule(_localctx, 100, RULE_thead); 11453 try { 11454 int _alt; 11455 enterOuterAlt(_localctx, 1); 11456 { 11457 setState(1296); 11458 theadTagOpen(); 11459 setState(1336); 11460 _errHandler.sync(this); 11461 _alt = getInterpreter().adaptivePredict(_input,91,_ctx); 11462 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 11463 if ( _alt==1 ) { 11464 { 11465 setState(1334); 11466 _errHandler.sync(this); 11467 switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) { 11468 case 1: 11469 { 11470 setState(1297); 11471 htmlTag(); 11472 } 11473 break; 11474 case 2: 11475 { 11476 setState(1298); 11477 singletonTag(); 11478 } 11479 break; 11480 case 3: 11481 { 11482 setState(1299); 11483 paragraph(); 11484 } 11485 break; 11486 case 4: 11487 { 11488 setState(1300); 11489 li(); 11490 } 11491 break; 11492 case 5: 11493 { 11494 setState(1301); 11495 tr(); 11496 } 11497 break; 11498 case 6: 11499 { 11500 setState(1302); 11501 td(); 11502 } 11503 break; 11504 case 7: 11505 { 11506 setState(1303); 11507 th(); 11508 } 11509 break; 11510 case 8: 11511 { 11512 setState(1304); 11513 body(); 11514 } 11515 break; 11516 case 9: 11517 { 11518 setState(1305); 11519 colgroup(); 11520 } 11521 break; 11522 case 10: 11523 { 11524 setState(1306); 11525 dd(); 11526 } 11527 break; 11528 case 11: 11529 { 11530 setState(1307); 11531 dt(); 11532 } 11533 break; 11534 case 12: 11535 { 11536 setState(1308); 11537 head(); 11538 } 11539 break; 11540 case 13: 11541 { 11542 setState(1309); 11543 html(); 11544 } 11545 break; 11546 case 14: 11547 { 11548 setState(1310); 11549 option(); 11550 } 11551 break; 11552 case 15: 11553 { 11554 setState(1311); 11555 tbody(); 11556 } 11557 break; 11558 case 16: 11559 { 11560 setState(1312); 11561 tfoot(); 11562 } 11563 break; 11564 case 17: 11565 { 11566 setState(1313); 11567 pTagOpen(); 11568 } 11569 break; 11570 case 18: 11571 { 11572 setState(1314); 11573 liTagOpen(); 11574 } 11575 break; 11576 case 19: 11577 { 11578 setState(1315); 11579 trTagOpen(); 11580 } 11581 break; 11582 case 20: 11583 { 11584 setState(1316); 11585 tdTagOpen(); 11586 } 11587 break; 11588 case 21: 11589 { 11590 setState(1317); 11591 thTagOpen(); 11592 } 11593 break; 11594 case 22: 11595 { 11596 setState(1318); 11597 bodyTagOpen(); 11598 } 11599 break; 11600 case 23: 11601 { 11602 setState(1319); 11603 colgroupTagOpen(); 11604 } 11605 break; 11606 case 24: 11607 { 11608 setState(1320); 11609 ddTagOpen(); 11610 } 11611 break; 11612 case 25: 11613 { 11614 setState(1321); 11615 dtTagOpen(); 11616 } 11617 break; 11618 case 26: 11619 { 11620 setState(1322); 11621 headTagOpen(); 11622 } 11623 break; 11624 case 27: 11625 { 11626 setState(1323); 11627 htmlTagOpen(); 11628 } 11629 break; 11630 case 28: 11631 { 11632 setState(1324); 11633 optionTagOpen(); 11634 } 11635 break; 11636 case 29: 11637 { 11638 setState(1325); 11639 tbodyTagOpen(); 11640 } 11641 break; 11642 case 30: 11643 { 11644 setState(1326); 11645 tfootTagOpen(); 11646 } 11647 break; 11648 case 31: 11649 { 11650 { 11651 setState(1327); 11652 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 11653 setState(1328); 11654 match(LEADING_ASTERISK); 11655 } 11656 } 11657 break; 11658 case 32: 11659 { 11660 setState(1329); 11661 htmlComment(); 11662 } 11663 break; 11664 case 33: 11665 { 11666 setState(1330); 11667 match(CDATA); 11668 } 11669 break; 11670 case 34: 11671 { 11672 setState(1331); 11673 match(NEWLINE); 11674 } 11675 break; 11676 case 35: 11677 { 11678 setState(1332); 11679 text(); 11680 } 11681 break; 11682 case 36: 11683 { 11684 setState(1333); 11685 javadocInlineTag(); 11686 } 11687 break; 11688 } 11689 } 11690 } 11691 setState(1338); 11692 _errHandler.sync(this); 11693 _alt = getInterpreter().adaptivePredict(_input,91,_ctx); 11694 } 11695 setState(1339); 11696 theadTagClose(); 11697 } 11698 } 11699 catch (RecognitionException re) { 11700 _localctx.exception = re; 11701 _errHandler.reportError(this, re); 11702 _errHandler.recover(this, re); 11703 } 11704 finally { 11705 exitRule(); 11706 } 11707 return _localctx; 11708 } 11709 11710 public static class SingletonElementContext extends ParserRuleContext { 11711 public SingletonTagContext singletonTag() { 11712 return getRuleContext(SingletonTagContext.class,0); 11713 } 11714 public AreaTagContext areaTag() { 11715 return getRuleContext(AreaTagContext.class,0); 11716 } 11717 public BaseTagContext baseTag() { 11718 return getRuleContext(BaseTagContext.class,0); 11719 } 11720 public BasefrontTagContext basefrontTag() { 11721 return getRuleContext(BasefrontTagContext.class,0); 11722 } 11723 public BrTagContext brTag() { 11724 return getRuleContext(BrTagContext.class,0); 11725 } 11726 public ColTagContext colTag() { 11727 return getRuleContext(ColTagContext.class,0); 11728 } 11729 public FrameTagContext frameTag() { 11730 return getRuleContext(FrameTagContext.class,0); 11731 } 11732 public HrTagContext hrTag() { 11733 return getRuleContext(HrTagContext.class,0); 11734 } 11735 public ImgTagContext imgTag() { 11736 return getRuleContext(ImgTagContext.class,0); 11737 } 11738 public InputTagContext inputTag() { 11739 return getRuleContext(InputTagContext.class,0); 11740 } 11741 public IsindexTagContext isindexTag() { 11742 return getRuleContext(IsindexTagContext.class,0); 11743 } 11744 public LinkTagContext linkTag() { 11745 return getRuleContext(LinkTagContext.class,0); 11746 } 11747 public MetaTagContext metaTag() { 11748 return getRuleContext(MetaTagContext.class,0); 11749 } 11750 public ParamTagContext paramTag() { 11751 return getRuleContext(ParamTagContext.class,0); 11752 } 11753 public WrongSinletonTagContext wrongSinletonTag() { 11754 return getRuleContext(WrongSinletonTagContext.class,0); 11755 } 11756 public SingletonElementContext(ParserRuleContext parent, int invokingState) { 11757 super(parent, invokingState); 11758 } 11759 @Override public int getRuleIndex() { return RULE_singletonElement; } 11760 @Override 11761 public void enterRule(ParseTreeListener listener) { 11762 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonElement(this); 11763 } 11764 @Override 11765 public void exitRule(ParseTreeListener listener) { 11766 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonElement(this); 11767 } 11768 @Override 11769 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11770 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonElement(this); 11771 else return visitor.visitChildren(this); 11772 } 11773 } 11774 11775 public final SingletonElementContext singletonElement() throws RecognitionException { 11776 SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState()); 11777 enterRule(_localctx, 102, RULE_singletonElement); 11778 try { 11779 setState(1356); 11780 _errHandler.sync(this); 11781 switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) { 11782 case 1: 11783 enterOuterAlt(_localctx, 1); 11784 { 11785 setState(1341); 11786 singletonTag(); 11787 } 11788 break; 11789 case 2: 11790 enterOuterAlt(_localctx, 2); 11791 { 11792 setState(1342); 11793 areaTag(); 11794 } 11795 break; 11796 case 3: 11797 enterOuterAlt(_localctx, 3); 11798 { 11799 setState(1343); 11800 baseTag(); 11801 } 11802 break; 11803 case 4: 11804 enterOuterAlt(_localctx, 4); 11805 { 11806 setState(1344); 11807 basefrontTag(); 11808 } 11809 break; 11810 case 5: 11811 enterOuterAlt(_localctx, 5); 11812 { 11813 setState(1345); 11814 brTag(); 11815 } 11816 break; 11817 case 6: 11818 enterOuterAlt(_localctx, 6); 11819 { 11820 setState(1346); 11821 colTag(); 11822 } 11823 break; 11824 case 7: 11825 enterOuterAlt(_localctx, 7); 11826 { 11827 setState(1347); 11828 frameTag(); 11829 } 11830 break; 11831 case 8: 11832 enterOuterAlt(_localctx, 8); 11833 { 11834 setState(1348); 11835 hrTag(); 11836 } 11837 break; 11838 case 9: 11839 enterOuterAlt(_localctx, 9); 11840 { 11841 setState(1349); 11842 imgTag(); 11843 } 11844 break; 11845 case 10: 11846 enterOuterAlt(_localctx, 10); 11847 { 11848 setState(1350); 11849 inputTag(); 11850 } 11851 break; 11852 case 11: 11853 enterOuterAlt(_localctx, 11); 11854 { 11855 setState(1351); 11856 isindexTag(); 11857 } 11858 break; 11859 case 12: 11860 enterOuterAlt(_localctx, 12); 11861 { 11862 setState(1352); 11863 linkTag(); 11864 } 11865 break; 11866 case 13: 11867 enterOuterAlt(_localctx, 13); 11868 { 11869 setState(1353); 11870 metaTag(); 11871 } 11872 break; 11873 case 14: 11874 enterOuterAlt(_localctx, 14); 11875 { 11876 setState(1354); 11877 paramTag(); 11878 } 11879 break; 11880 case 15: 11881 enterOuterAlt(_localctx, 15); 11882 { 11883 setState(1355); 11884 wrongSinletonTag(); 11885 } 11886 break; 11887 } 11888 } 11889 catch (RecognitionException re) { 11890 _localctx.exception = re; 11891 _errHandler.reportError(this, re); 11892 _errHandler.recover(this, re); 11893 } 11894 finally { 11895 exitRule(); 11896 } 11897 return _localctx; 11898 } 11899 11900 public static class SingletonTagContext extends ParserRuleContext { 11901 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11902 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 11903 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 11904 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 11905 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 11906 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 11907 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 11908 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 11909 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 11910 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 11911 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 11912 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 11913 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 11914 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 11915 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 11916 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 11917 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 11918 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11919 public List<AttributeContext> attribute() { 11920 return getRuleContexts(AttributeContext.class); 11921 } 11922 public AttributeContext attribute(int i) { 11923 return getRuleContext(AttributeContext.class,i); 11924 } 11925 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11926 public TerminalNode NEWLINE(int i) { 11927 return getToken(JavadocParser.NEWLINE, i); 11928 } 11929 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11930 public TerminalNode LEADING_ASTERISK(int i) { 11931 return getToken(JavadocParser.LEADING_ASTERISK, i); 11932 } 11933 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11934 public TerminalNode WS(int i) { 11935 return getToken(JavadocParser.WS, i); 11936 } 11937 public SingletonTagContext(ParserRuleContext parent, int invokingState) { 11938 super(parent, invokingState); 11939 } 11940 @Override public int getRuleIndex() { return RULE_singletonTag; } 11941 @Override 11942 public void enterRule(ParseTreeListener listener) { 11943 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTag(this); 11944 } 11945 @Override 11946 public void exitRule(ParseTreeListener listener) { 11947 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTag(this); 11948 } 11949 @Override 11950 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11951 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTag(this); 11952 else return visitor.visitChildren(this); 11953 } 11954 } 11955 11956 public final SingletonTagContext singletonTag() throws RecognitionException { 11957 SingletonTagContext _localctx = new SingletonTagContext(_ctx, getState()); 11958 enterRule(_localctx, 104, RULE_singletonTag); 11959 int _la; 11960 try { 11961 enterOuterAlt(_localctx, 1); 11962 { 11963 setState(1358); 11964 match(OPEN); 11965 setState(1359); 11966 _la = _input.LA(1); 11967 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)) ) { 11968 _errHandler.recoverInline(this); 11969 } else { 11970 consume(); 11971 } 11972 setState(1366); 11973 _errHandler.sync(this); 11974 _la = _input.LA(1); 11975 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11976 { 11977 setState(1364); 11978 switch (_input.LA(1)) { 11979 case HTML_TAG_NAME: 11980 { 11981 setState(1360); 11982 attribute(); 11983 } 11984 break; 11985 case NEWLINE: 11986 { 11987 setState(1361); 11988 match(NEWLINE); 11989 } 11990 break; 11991 case LEADING_ASTERISK: 11992 { 11993 setState(1362); 11994 match(LEADING_ASTERISK); 11995 } 11996 break; 11997 case WS: 11998 { 11999 setState(1363); 12000 match(WS); 12001 } 12002 break; 12003 default: 12004 throw new NoViableAltException(this); 12005 } 12006 } 12007 setState(1368); 12008 _errHandler.sync(this); 12009 _la = _input.LA(1); 12010 } 12011 setState(1369); 12012 match(SLASH_CLOSE); 12013 } 12014 } 12015 catch (RecognitionException re) { 12016 _localctx.exception = re; 12017 _errHandler.reportError(this, re); 12018 _errHandler.recover(this, re); 12019 } 12020 finally { 12021 exitRule(); 12022 } 12023 return _localctx; 12024 } 12025 12026 public static class AreaTagContext extends ParserRuleContext { 12027 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12028 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 12029 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12030 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12031 public List<AttributeContext> attribute() { 12032 return getRuleContexts(AttributeContext.class); 12033 } 12034 public AttributeContext attribute(int i) { 12035 return getRuleContext(AttributeContext.class,i); 12036 } 12037 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12038 public TerminalNode NEWLINE(int i) { 12039 return getToken(JavadocParser.NEWLINE, i); 12040 } 12041 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12042 public TerminalNode LEADING_ASTERISK(int i) { 12043 return getToken(JavadocParser.LEADING_ASTERISK, i); 12044 } 12045 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12046 public TerminalNode WS(int i) { 12047 return getToken(JavadocParser.WS, i); 12048 } 12049 public AreaTagContext(ParserRuleContext parent, int invokingState) { 12050 super(parent, invokingState); 12051 } 12052 @Override public int getRuleIndex() { return RULE_areaTag; } 12053 @Override 12054 public void enterRule(ParseTreeListener listener) { 12055 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAreaTag(this); 12056 } 12057 @Override 12058 public void exitRule(ParseTreeListener listener) { 12059 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAreaTag(this); 12060 } 12061 @Override 12062 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12063 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAreaTag(this); 12064 else return visitor.visitChildren(this); 12065 } 12066 } 12067 12068 public final AreaTagContext areaTag() throws RecognitionException { 12069 AreaTagContext _localctx = new AreaTagContext(_ctx, getState()); 12070 enterRule(_localctx, 106, RULE_areaTag); 12071 int _la; 12072 try { 12073 enterOuterAlt(_localctx, 1); 12074 { 12075 setState(1371); 12076 match(OPEN); 12077 setState(1372); 12078 match(AREA_HTML_TAG_NAME); 12079 setState(1379); 12080 _errHandler.sync(this); 12081 _la = _input.LA(1); 12082 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12083 { 12084 setState(1377); 12085 switch (_input.LA(1)) { 12086 case HTML_TAG_NAME: 12087 { 12088 setState(1373); 12089 attribute(); 12090 } 12091 break; 12092 case NEWLINE: 12093 { 12094 setState(1374); 12095 match(NEWLINE); 12096 } 12097 break; 12098 case LEADING_ASTERISK: 12099 { 12100 setState(1375); 12101 match(LEADING_ASTERISK); 12102 } 12103 break; 12104 case WS: 12105 { 12106 setState(1376); 12107 match(WS); 12108 } 12109 break; 12110 default: 12111 throw new NoViableAltException(this); 12112 } 12113 } 12114 setState(1381); 12115 _errHandler.sync(this); 12116 _la = _input.LA(1); 12117 } 12118 setState(1382); 12119 _la = _input.LA(1); 12120 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12121 _errHandler.recoverInline(this); 12122 } else { 12123 consume(); 12124 } 12125 } 12126 } 12127 catch (RecognitionException re) { 12128 _localctx.exception = re; 12129 _errHandler.reportError(this, re); 12130 _errHandler.recover(this, re); 12131 } 12132 finally { 12133 exitRule(); 12134 } 12135 return _localctx; 12136 } 12137 12138 public static class BaseTagContext extends ParserRuleContext { 12139 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12140 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 12141 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12142 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12143 public List<AttributeContext> attribute() { 12144 return getRuleContexts(AttributeContext.class); 12145 } 12146 public AttributeContext attribute(int i) { 12147 return getRuleContext(AttributeContext.class,i); 12148 } 12149 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12150 public TerminalNode NEWLINE(int i) { 12151 return getToken(JavadocParser.NEWLINE, i); 12152 } 12153 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12154 public TerminalNode LEADING_ASTERISK(int i) { 12155 return getToken(JavadocParser.LEADING_ASTERISK, i); 12156 } 12157 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12158 public TerminalNode WS(int i) { 12159 return getToken(JavadocParser.WS, i); 12160 } 12161 public BaseTagContext(ParserRuleContext parent, int invokingState) { 12162 super(parent, invokingState); 12163 } 12164 @Override public int getRuleIndex() { return RULE_baseTag; } 12165 @Override 12166 public void enterRule(ParseTreeListener listener) { 12167 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBaseTag(this); 12168 } 12169 @Override 12170 public void exitRule(ParseTreeListener listener) { 12171 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBaseTag(this); 12172 } 12173 @Override 12174 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12175 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBaseTag(this); 12176 else return visitor.visitChildren(this); 12177 } 12178 } 12179 12180 public final BaseTagContext baseTag() throws RecognitionException { 12181 BaseTagContext _localctx = new BaseTagContext(_ctx, getState()); 12182 enterRule(_localctx, 108, RULE_baseTag); 12183 int _la; 12184 try { 12185 enterOuterAlt(_localctx, 1); 12186 { 12187 setState(1384); 12188 match(OPEN); 12189 setState(1385); 12190 match(BASE_HTML_TAG_NAME); 12191 setState(1392); 12192 _errHandler.sync(this); 12193 _la = _input.LA(1); 12194 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12195 { 12196 setState(1390); 12197 switch (_input.LA(1)) { 12198 case HTML_TAG_NAME: 12199 { 12200 setState(1386); 12201 attribute(); 12202 } 12203 break; 12204 case NEWLINE: 12205 { 12206 setState(1387); 12207 match(NEWLINE); 12208 } 12209 break; 12210 case LEADING_ASTERISK: 12211 { 12212 setState(1388); 12213 match(LEADING_ASTERISK); 12214 } 12215 break; 12216 case WS: 12217 { 12218 setState(1389); 12219 match(WS); 12220 } 12221 break; 12222 default: 12223 throw new NoViableAltException(this); 12224 } 12225 } 12226 setState(1394); 12227 _errHandler.sync(this); 12228 _la = _input.LA(1); 12229 } 12230 setState(1395); 12231 _la = _input.LA(1); 12232 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12233 _errHandler.recoverInline(this); 12234 } else { 12235 consume(); 12236 } 12237 } 12238 } 12239 catch (RecognitionException re) { 12240 _localctx.exception = re; 12241 _errHandler.reportError(this, re); 12242 _errHandler.recover(this, re); 12243 } 12244 finally { 12245 exitRule(); 12246 } 12247 return _localctx; 12248 } 12249 12250 public static class BasefrontTagContext extends ParserRuleContext { 12251 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12252 public TerminalNode BASEFRONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFRONT_HTML_TAG_NAME, 0); } 12253 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12254 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12255 public List<AttributeContext> attribute() { 12256 return getRuleContexts(AttributeContext.class); 12257 } 12258 public AttributeContext attribute(int i) { 12259 return getRuleContext(AttributeContext.class,i); 12260 } 12261 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12262 public TerminalNode NEWLINE(int i) { 12263 return getToken(JavadocParser.NEWLINE, i); 12264 } 12265 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12266 public TerminalNode LEADING_ASTERISK(int i) { 12267 return getToken(JavadocParser.LEADING_ASTERISK, i); 12268 } 12269 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12270 public TerminalNode WS(int i) { 12271 return getToken(JavadocParser.WS, i); 12272 } 12273 public BasefrontTagContext(ParserRuleContext parent, int invokingState) { 12274 super(parent, invokingState); 12275 } 12276 @Override public int getRuleIndex() { return RULE_basefrontTag; } 12277 @Override 12278 public void enterRule(ParseTreeListener listener) { 12279 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBasefrontTag(this); 12280 } 12281 @Override 12282 public void exitRule(ParseTreeListener listener) { 12283 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBasefrontTag(this); 12284 } 12285 @Override 12286 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12287 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBasefrontTag(this); 12288 else return visitor.visitChildren(this); 12289 } 12290 } 12291 12292 public final BasefrontTagContext basefrontTag() throws RecognitionException { 12293 BasefrontTagContext _localctx = new BasefrontTagContext(_ctx, getState()); 12294 enterRule(_localctx, 110, RULE_basefrontTag); 12295 int _la; 12296 try { 12297 enterOuterAlt(_localctx, 1); 12298 { 12299 setState(1397); 12300 match(OPEN); 12301 setState(1398); 12302 match(BASEFRONT_HTML_TAG_NAME); 12303 setState(1405); 12304 _errHandler.sync(this); 12305 _la = _input.LA(1); 12306 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12307 { 12308 setState(1403); 12309 switch (_input.LA(1)) { 12310 case HTML_TAG_NAME: 12311 { 12312 setState(1399); 12313 attribute(); 12314 } 12315 break; 12316 case NEWLINE: 12317 { 12318 setState(1400); 12319 match(NEWLINE); 12320 } 12321 break; 12322 case LEADING_ASTERISK: 12323 { 12324 setState(1401); 12325 match(LEADING_ASTERISK); 12326 } 12327 break; 12328 case WS: 12329 { 12330 setState(1402); 12331 match(WS); 12332 } 12333 break; 12334 default: 12335 throw new NoViableAltException(this); 12336 } 12337 } 12338 setState(1407); 12339 _errHandler.sync(this); 12340 _la = _input.LA(1); 12341 } 12342 setState(1408); 12343 _la = _input.LA(1); 12344 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12345 _errHandler.recoverInline(this); 12346 } else { 12347 consume(); 12348 } 12349 } 12350 } 12351 catch (RecognitionException re) { 12352 _localctx.exception = re; 12353 _errHandler.reportError(this, re); 12354 _errHandler.recover(this, re); 12355 } 12356 finally { 12357 exitRule(); 12358 } 12359 return _localctx; 12360 } 12361 12362 public static class BrTagContext extends ParserRuleContext { 12363 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12364 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 12365 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12366 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12367 public List<AttributeContext> attribute() { 12368 return getRuleContexts(AttributeContext.class); 12369 } 12370 public AttributeContext attribute(int i) { 12371 return getRuleContext(AttributeContext.class,i); 12372 } 12373 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12374 public TerminalNode NEWLINE(int i) { 12375 return getToken(JavadocParser.NEWLINE, i); 12376 } 12377 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12378 public TerminalNode LEADING_ASTERISK(int i) { 12379 return getToken(JavadocParser.LEADING_ASTERISK, i); 12380 } 12381 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12382 public TerminalNode WS(int i) { 12383 return getToken(JavadocParser.WS, i); 12384 } 12385 public BrTagContext(ParserRuleContext parent, int invokingState) { 12386 super(parent, invokingState); 12387 } 12388 @Override public int getRuleIndex() { return RULE_brTag; } 12389 @Override 12390 public void enterRule(ParseTreeListener listener) { 12391 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBrTag(this); 12392 } 12393 @Override 12394 public void exitRule(ParseTreeListener listener) { 12395 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBrTag(this); 12396 } 12397 @Override 12398 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12399 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBrTag(this); 12400 else return visitor.visitChildren(this); 12401 } 12402 } 12403 12404 public final BrTagContext brTag() throws RecognitionException { 12405 BrTagContext _localctx = new BrTagContext(_ctx, getState()); 12406 enterRule(_localctx, 112, RULE_brTag); 12407 int _la; 12408 try { 12409 enterOuterAlt(_localctx, 1); 12410 { 12411 setState(1410); 12412 match(OPEN); 12413 setState(1411); 12414 match(BR_HTML_TAG_NAME); 12415 setState(1418); 12416 _errHandler.sync(this); 12417 _la = _input.LA(1); 12418 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12419 { 12420 setState(1416); 12421 switch (_input.LA(1)) { 12422 case HTML_TAG_NAME: 12423 { 12424 setState(1412); 12425 attribute(); 12426 } 12427 break; 12428 case NEWLINE: 12429 { 12430 setState(1413); 12431 match(NEWLINE); 12432 } 12433 break; 12434 case LEADING_ASTERISK: 12435 { 12436 setState(1414); 12437 match(LEADING_ASTERISK); 12438 } 12439 break; 12440 case WS: 12441 { 12442 setState(1415); 12443 match(WS); 12444 } 12445 break; 12446 default: 12447 throw new NoViableAltException(this); 12448 } 12449 } 12450 setState(1420); 12451 _errHandler.sync(this); 12452 _la = _input.LA(1); 12453 } 12454 setState(1421); 12455 _la = _input.LA(1); 12456 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12457 _errHandler.recoverInline(this); 12458 } else { 12459 consume(); 12460 } 12461 } 12462 } 12463 catch (RecognitionException re) { 12464 _localctx.exception = re; 12465 _errHandler.reportError(this, re); 12466 _errHandler.recover(this, re); 12467 } 12468 finally { 12469 exitRule(); 12470 } 12471 return _localctx; 12472 } 12473 12474 public static class ColTagContext extends ParserRuleContext { 12475 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12476 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 12477 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12478 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12479 public List<AttributeContext> attribute() { 12480 return getRuleContexts(AttributeContext.class); 12481 } 12482 public AttributeContext attribute(int i) { 12483 return getRuleContext(AttributeContext.class,i); 12484 } 12485 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12486 public TerminalNode NEWLINE(int i) { 12487 return getToken(JavadocParser.NEWLINE, i); 12488 } 12489 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12490 public TerminalNode LEADING_ASTERISK(int i) { 12491 return getToken(JavadocParser.LEADING_ASTERISK, i); 12492 } 12493 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12494 public TerminalNode WS(int i) { 12495 return getToken(JavadocParser.WS, i); 12496 } 12497 public ColTagContext(ParserRuleContext parent, int invokingState) { 12498 super(parent, invokingState); 12499 } 12500 @Override public int getRuleIndex() { return RULE_colTag; } 12501 @Override 12502 public void enterRule(ParseTreeListener listener) { 12503 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColTag(this); 12504 } 12505 @Override 12506 public void exitRule(ParseTreeListener listener) { 12507 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColTag(this); 12508 } 12509 @Override 12510 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12511 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColTag(this); 12512 else return visitor.visitChildren(this); 12513 } 12514 } 12515 12516 public final ColTagContext colTag() throws RecognitionException { 12517 ColTagContext _localctx = new ColTagContext(_ctx, getState()); 12518 enterRule(_localctx, 114, RULE_colTag); 12519 int _la; 12520 try { 12521 enterOuterAlt(_localctx, 1); 12522 { 12523 setState(1423); 12524 match(OPEN); 12525 setState(1424); 12526 match(COL_HTML_TAG_NAME); 12527 setState(1431); 12528 _errHandler.sync(this); 12529 _la = _input.LA(1); 12530 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12531 { 12532 setState(1429); 12533 switch (_input.LA(1)) { 12534 case HTML_TAG_NAME: 12535 { 12536 setState(1425); 12537 attribute(); 12538 } 12539 break; 12540 case NEWLINE: 12541 { 12542 setState(1426); 12543 match(NEWLINE); 12544 } 12545 break; 12546 case LEADING_ASTERISK: 12547 { 12548 setState(1427); 12549 match(LEADING_ASTERISK); 12550 } 12551 break; 12552 case WS: 12553 { 12554 setState(1428); 12555 match(WS); 12556 } 12557 break; 12558 default: 12559 throw new NoViableAltException(this); 12560 } 12561 } 12562 setState(1433); 12563 _errHandler.sync(this); 12564 _la = _input.LA(1); 12565 } 12566 setState(1434); 12567 _la = _input.LA(1); 12568 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12569 _errHandler.recoverInline(this); 12570 } else { 12571 consume(); 12572 } 12573 } 12574 } 12575 catch (RecognitionException re) { 12576 _localctx.exception = re; 12577 _errHandler.reportError(this, re); 12578 _errHandler.recover(this, re); 12579 } 12580 finally { 12581 exitRule(); 12582 } 12583 return _localctx; 12584 } 12585 12586 public static class FrameTagContext extends ParserRuleContext { 12587 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12588 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 12589 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12590 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12591 public List<AttributeContext> attribute() { 12592 return getRuleContexts(AttributeContext.class); 12593 } 12594 public AttributeContext attribute(int i) { 12595 return getRuleContext(AttributeContext.class,i); 12596 } 12597 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12598 public TerminalNode NEWLINE(int i) { 12599 return getToken(JavadocParser.NEWLINE, i); 12600 } 12601 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12602 public TerminalNode LEADING_ASTERISK(int i) { 12603 return getToken(JavadocParser.LEADING_ASTERISK, i); 12604 } 12605 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12606 public TerminalNode WS(int i) { 12607 return getToken(JavadocParser.WS, i); 12608 } 12609 public FrameTagContext(ParserRuleContext parent, int invokingState) { 12610 super(parent, invokingState); 12611 } 12612 @Override public int getRuleIndex() { return RULE_frameTag; } 12613 @Override 12614 public void enterRule(ParseTreeListener listener) { 12615 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterFrameTag(this); 12616 } 12617 @Override 12618 public void exitRule(ParseTreeListener listener) { 12619 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitFrameTag(this); 12620 } 12621 @Override 12622 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12623 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitFrameTag(this); 12624 else return visitor.visitChildren(this); 12625 } 12626 } 12627 12628 public final FrameTagContext frameTag() throws RecognitionException { 12629 FrameTagContext _localctx = new FrameTagContext(_ctx, getState()); 12630 enterRule(_localctx, 116, RULE_frameTag); 12631 int _la; 12632 try { 12633 enterOuterAlt(_localctx, 1); 12634 { 12635 setState(1436); 12636 match(OPEN); 12637 setState(1437); 12638 match(FRAME_HTML_TAG_NAME); 12639 setState(1444); 12640 _errHandler.sync(this); 12641 _la = _input.LA(1); 12642 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12643 { 12644 setState(1442); 12645 switch (_input.LA(1)) { 12646 case HTML_TAG_NAME: 12647 { 12648 setState(1438); 12649 attribute(); 12650 } 12651 break; 12652 case NEWLINE: 12653 { 12654 setState(1439); 12655 match(NEWLINE); 12656 } 12657 break; 12658 case LEADING_ASTERISK: 12659 { 12660 setState(1440); 12661 match(LEADING_ASTERISK); 12662 } 12663 break; 12664 case WS: 12665 { 12666 setState(1441); 12667 match(WS); 12668 } 12669 break; 12670 default: 12671 throw new NoViableAltException(this); 12672 } 12673 } 12674 setState(1446); 12675 _errHandler.sync(this); 12676 _la = _input.LA(1); 12677 } 12678 setState(1447); 12679 _la = _input.LA(1); 12680 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12681 _errHandler.recoverInline(this); 12682 } else { 12683 consume(); 12684 } 12685 } 12686 } 12687 catch (RecognitionException re) { 12688 _localctx.exception = re; 12689 _errHandler.reportError(this, re); 12690 _errHandler.recover(this, re); 12691 } 12692 finally { 12693 exitRule(); 12694 } 12695 return _localctx; 12696 } 12697 12698 public static class HrTagContext extends ParserRuleContext { 12699 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12700 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 12701 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12702 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12703 public List<AttributeContext> attribute() { 12704 return getRuleContexts(AttributeContext.class); 12705 } 12706 public AttributeContext attribute(int i) { 12707 return getRuleContext(AttributeContext.class,i); 12708 } 12709 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12710 public TerminalNode NEWLINE(int i) { 12711 return getToken(JavadocParser.NEWLINE, i); 12712 } 12713 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12714 public TerminalNode LEADING_ASTERISK(int i) { 12715 return getToken(JavadocParser.LEADING_ASTERISK, i); 12716 } 12717 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12718 public TerminalNode WS(int i) { 12719 return getToken(JavadocParser.WS, i); 12720 } 12721 public HrTagContext(ParserRuleContext parent, int invokingState) { 12722 super(parent, invokingState); 12723 } 12724 @Override public int getRuleIndex() { return RULE_hrTag; } 12725 @Override 12726 public void enterRule(ParseTreeListener listener) { 12727 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHrTag(this); 12728 } 12729 @Override 12730 public void exitRule(ParseTreeListener listener) { 12731 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHrTag(this); 12732 } 12733 @Override 12734 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12735 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHrTag(this); 12736 else return visitor.visitChildren(this); 12737 } 12738 } 12739 12740 public final HrTagContext hrTag() throws RecognitionException { 12741 HrTagContext _localctx = new HrTagContext(_ctx, getState()); 12742 enterRule(_localctx, 118, RULE_hrTag); 12743 int _la; 12744 try { 12745 enterOuterAlt(_localctx, 1); 12746 { 12747 setState(1449); 12748 match(OPEN); 12749 setState(1450); 12750 match(HR_HTML_TAG_NAME); 12751 setState(1457); 12752 _errHandler.sync(this); 12753 _la = _input.LA(1); 12754 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12755 { 12756 setState(1455); 12757 switch (_input.LA(1)) { 12758 case HTML_TAG_NAME: 12759 { 12760 setState(1451); 12761 attribute(); 12762 } 12763 break; 12764 case NEWLINE: 12765 { 12766 setState(1452); 12767 match(NEWLINE); 12768 } 12769 break; 12770 case LEADING_ASTERISK: 12771 { 12772 setState(1453); 12773 match(LEADING_ASTERISK); 12774 } 12775 break; 12776 case WS: 12777 { 12778 setState(1454); 12779 match(WS); 12780 } 12781 break; 12782 default: 12783 throw new NoViableAltException(this); 12784 } 12785 } 12786 setState(1459); 12787 _errHandler.sync(this); 12788 _la = _input.LA(1); 12789 } 12790 setState(1460); 12791 _la = _input.LA(1); 12792 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12793 _errHandler.recoverInline(this); 12794 } else { 12795 consume(); 12796 } 12797 } 12798 } 12799 catch (RecognitionException re) { 12800 _localctx.exception = re; 12801 _errHandler.reportError(this, re); 12802 _errHandler.recover(this, re); 12803 } 12804 finally { 12805 exitRule(); 12806 } 12807 return _localctx; 12808 } 12809 12810 public static class ImgTagContext extends ParserRuleContext { 12811 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12812 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 12813 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12814 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12815 public List<AttributeContext> attribute() { 12816 return getRuleContexts(AttributeContext.class); 12817 } 12818 public AttributeContext attribute(int i) { 12819 return getRuleContext(AttributeContext.class,i); 12820 } 12821 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12822 public TerminalNode NEWLINE(int i) { 12823 return getToken(JavadocParser.NEWLINE, i); 12824 } 12825 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12826 public TerminalNode LEADING_ASTERISK(int i) { 12827 return getToken(JavadocParser.LEADING_ASTERISK, i); 12828 } 12829 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12830 public TerminalNode WS(int i) { 12831 return getToken(JavadocParser.WS, i); 12832 } 12833 public ImgTagContext(ParserRuleContext parent, int invokingState) { 12834 super(parent, invokingState); 12835 } 12836 @Override public int getRuleIndex() { return RULE_imgTag; } 12837 @Override 12838 public void enterRule(ParseTreeListener listener) { 12839 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterImgTag(this); 12840 } 12841 @Override 12842 public void exitRule(ParseTreeListener listener) { 12843 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitImgTag(this); 12844 } 12845 @Override 12846 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12847 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitImgTag(this); 12848 else return visitor.visitChildren(this); 12849 } 12850 } 12851 12852 public final ImgTagContext imgTag() throws RecognitionException { 12853 ImgTagContext _localctx = new ImgTagContext(_ctx, getState()); 12854 enterRule(_localctx, 120, RULE_imgTag); 12855 int _la; 12856 try { 12857 enterOuterAlt(_localctx, 1); 12858 { 12859 setState(1462); 12860 match(OPEN); 12861 setState(1463); 12862 match(IMG_HTML_TAG_NAME); 12863 setState(1470); 12864 _errHandler.sync(this); 12865 _la = _input.LA(1); 12866 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12867 { 12868 setState(1468); 12869 switch (_input.LA(1)) { 12870 case HTML_TAG_NAME: 12871 { 12872 setState(1464); 12873 attribute(); 12874 } 12875 break; 12876 case NEWLINE: 12877 { 12878 setState(1465); 12879 match(NEWLINE); 12880 } 12881 break; 12882 case LEADING_ASTERISK: 12883 { 12884 setState(1466); 12885 match(LEADING_ASTERISK); 12886 } 12887 break; 12888 case WS: 12889 { 12890 setState(1467); 12891 match(WS); 12892 } 12893 break; 12894 default: 12895 throw new NoViableAltException(this); 12896 } 12897 } 12898 setState(1472); 12899 _errHandler.sync(this); 12900 _la = _input.LA(1); 12901 } 12902 setState(1473); 12903 _la = _input.LA(1); 12904 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12905 _errHandler.recoverInline(this); 12906 } else { 12907 consume(); 12908 } 12909 } 12910 } 12911 catch (RecognitionException re) { 12912 _localctx.exception = re; 12913 _errHandler.reportError(this, re); 12914 _errHandler.recover(this, re); 12915 } 12916 finally { 12917 exitRule(); 12918 } 12919 return _localctx; 12920 } 12921 12922 public static class InputTagContext extends ParserRuleContext { 12923 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12924 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 12925 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12926 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12927 public List<AttributeContext> attribute() { 12928 return getRuleContexts(AttributeContext.class); 12929 } 12930 public AttributeContext attribute(int i) { 12931 return getRuleContext(AttributeContext.class,i); 12932 } 12933 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12934 public TerminalNode NEWLINE(int i) { 12935 return getToken(JavadocParser.NEWLINE, i); 12936 } 12937 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12938 public TerminalNode LEADING_ASTERISK(int i) { 12939 return getToken(JavadocParser.LEADING_ASTERISK, i); 12940 } 12941 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12942 public TerminalNode WS(int i) { 12943 return getToken(JavadocParser.WS, i); 12944 } 12945 public InputTagContext(ParserRuleContext parent, int invokingState) { 12946 super(parent, invokingState); 12947 } 12948 @Override public int getRuleIndex() { return RULE_inputTag; } 12949 @Override 12950 public void enterRule(ParseTreeListener listener) { 12951 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInputTag(this); 12952 } 12953 @Override 12954 public void exitRule(ParseTreeListener listener) { 12955 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInputTag(this); 12956 } 12957 @Override 12958 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12959 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInputTag(this); 12960 else return visitor.visitChildren(this); 12961 } 12962 } 12963 12964 public final InputTagContext inputTag() throws RecognitionException { 12965 InputTagContext _localctx = new InputTagContext(_ctx, getState()); 12966 enterRule(_localctx, 122, RULE_inputTag); 12967 int _la; 12968 try { 12969 enterOuterAlt(_localctx, 1); 12970 { 12971 setState(1475); 12972 match(OPEN); 12973 setState(1476); 12974 match(INPUT_HTML_TAG_NAME); 12975 setState(1483); 12976 _errHandler.sync(this); 12977 _la = _input.LA(1); 12978 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12979 { 12980 setState(1481); 12981 switch (_input.LA(1)) { 12982 case HTML_TAG_NAME: 12983 { 12984 setState(1477); 12985 attribute(); 12986 } 12987 break; 12988 case NEWLINE: 12989 { 12990 setState(1478); 12991 match(NEWLINE); 12992 } 12993 break; 12994 case LEADING_ASTERISK: 12995 { 12996 setState(1479); 12997 match(LEADING_ASTERISK); 12998 } 12999 break; 13000 case WS: 13001 { 13002 setState(1480); 13003 match(WS); 13004 } 13005 break; 13006 default: 13007 throw new NoViableAltException(this); 13008 } 13009 } 13010 setState(1485); 13011 _errHandler.sync(this); 13012 _la = _input.LA(1); 13013 } 13014 setState(1486); 13015 _la = _input.LA(1); 13016 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13017 _errHandler.recoverInline(this); 13018 } else { 13019 consume(); 13020 } 13021 } 13022 } 13023 catch (RecognitionException re) { 13024 _localctx.exception = re; 13025 _errHandler.reportError(this, re); 13026 _errHandler.recover(this, re); 13027 } 13028 finally { 13029 exitRule(); 13030 } 13031 return _localctx; 13032 } 13033 13034 public static class IsindexTagContext extends ParserRuleContext { 13035 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13036 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 13037 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13038 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13039 public List<AttributeContext> attribute() { 13040 return getRuleContexts(AttributeContext.class); 13041 } 13042 public AttributeContext attribute(int i) { 13043 return getRuleContext(AttributeContext.class,i); 13044 } 13045 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13046 public TerminalNode NEWLINE(int i) { 13047 return getToken(JavadocParser.NEWLINE, i); 13048 } 13049 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13050 public TerminalNode LEADING_ASTERISK(int i) { 13051 return getToken(JavadocParser.LEADING_ASTERISK, i); 13052 } 13053 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13054 public TerminalNode WS(int i) { 13055 return getToken(JavadocParser.WS, i); 13056 } 13057 public IsindexTagContext(ParserRuleContext parent, int invokingState) { 13058 super(parent, invokingState); 13059 } 13060 @Override public int getRuleIndex() { return RULE_isindexTag; } 13061 @Override 13062 public void enterRule(ParseTreeListener listener) { 13063 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterIsindexTag(this); 13064 } 13065 @Override 13066 public void exitRule(ParseTreeListener listener) { 13067 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitIsindexTag(this); 13068 } 13069 @Override 13070 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13071 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitIsindexTag(this); 13072 else return visitor.visitChildren(this); 13073 } 13074 } 13075 13076 public final IsindexTagContext isindexTag() throws RecognitionException { 13077 IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState()); 13078 enterRule(_localctx, 124, RULE_isindexTag); 13079 int _la; 13080 try { 13081 enterOuterAlt(_localctx, 1); 13082 { 13083 setState(1488); 13084 match(OPEN); 13085 setState(1489); 13086 match(ISINDEX_HTML_TAG_NAME); 13087 setState(1496); 13088 _errHandler.sync(this); 13089 _la = _input.LA(1); 13090 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13091 { 13092 setState(1494); 13093 switch (_input.LA(1)) { 13094 case HTML_TAG_NAME: 13095 { 13096 setState(1490); 13097 attribute(); 13098 } 13099 break; 13100 case NEWLINE: 13101 { 13102 setState(1491); 13103 match(NEWLINE); 13104 } 13105 break; 13106 case LEADING_ASTERISK: 13107 { 13108 setState(1492); 13109 match(LEADING_ASTERISK); 13110 } 13111 break; 13112 case WS: 13113 { 13114 setState(1493); 13115 match(WS); 13116 } 13117 break; 13118 default: 13119 throw new NoViableAltException(this); 13120 } 13121 } 13122 setState(1498); 13123 _errHandler.sync(this); 13124 _la = _input.LA(1); 13125 } 13126 setState(1499); 13127 _la = _input.LA(1); 13128 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13129 _errHandler.recoverInline(this); 13130 } else { 13131 consume(); 13132 } 13133 } 13134 } 13135 catch (RecognitionException re) { 13136 _localctx.exception = re; 13137 _errHandler.reportError(this, re); 13138 _errHandler.recover(this, re); 13139 } 13140 finally { 13141 exitRule(); 13142 } 13143 return _localctx; 13144 } 13145 13146 public static class LinkTagContext extends ParserRuleContext { 13147 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13148 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 13149 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13150 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13151 public List<AttributeContext> attribute() { 13152 return getRuleContexts(AttributeContext.class); 13153 } 13154 public AttributeContext attribute(int i) { 13155 return getRuleContext(AttributeContext.class,i); 13156 } 13157 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13158 public TerminalNode NEWLINE(int i) { 13159 return getToken(JavadocParser.NEWLINE, i); 13160 } 13161 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13162 public TerminalNode LEADING_ASTERISK(int i) { 13163 return getToken(JavadocParser.LEADING_ASTERISK, i); 13164 } 13165 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13166 public TerminalNode WS(int i) { 13167 return getToken(JavadocParser.WS, i); 13168 } 13169 public LinkTagContext(ParserRuleContext parent, int invokingState) { 13170 super(parent, invokingState); 13171 } 13172 @Override public int getRuleIndex() { return RULE_linkTag; } 13173 @Override 13174 public void enterRule(ParseTreeListener listener) { 13175 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLinkTag(this); 13176 } 13177 @Override 13178 public void exitRule(ParseTreeListener listener) { 13179 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLinkTag(this); 13180 } 13181 @Override 13182 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13183 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLinkTag(this); 13184 else return visitor.visitChildren(this); 13185 } 13186 } 13187 13188 public final LinkTagContext linkTag() throws RecognitionException { 13189 LinkTagContext _localctx = new LinkTagContext(_ctx, getState()); 13190 enterRule(_localctx, 126, RULE_linkTag); 13191 int _la; 13192 try { 13193 enterOuterAlt(_localctx, 1); 13194 { 13195 setState(1501); 13196 match(OPEN); 13197 setState(1502); 13198 match(LINK_HTML_TAG_NAME); 13199 setState(1509); 13200 _errHandler.sync(this); 13201 _la = _input.LA(1); 13202 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13203 { 13204 setState(1507); 13205 switch (_input.LA(1)) { 13206 case HTML_TAG_NAME: 13207 { 13208 setState(1503); 13209 attribute(); 13210 } 13211 break; 13212 case NEWLINE: 13213 { 13214 setState(1504); 13215 match(NEWLINE); 13216 } 13217 break; 13218 case LEADING_ASTERISK: 13219 { 13220 setState(1505); 13221 match(LEADING_ASTERISK); 13222 } 13223 break; 13224 case WS: 13225 { 13226 setState(1506); 13227 match(WS); 13228 } 13229 break; 13230 default: 13231 throw new NoViableAltException(this); 13232 } 13233 } 13234 setState(1511); 13235 _errHandler.sync(this); 13236 _la = _input.LA(1); 13237 } 13238 setState(1512); 13239 _la = _input.LA(1); 13240 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13241 _errHandler.recoverInline(this); 13242 } else { 13243 consume(); 13244 } 13245 } 13246 } 13247 catch (RecognitionException re) { 13248 _localctx.exception = re; 13249 _errHandler.reportError(this, re); 13250 _errHandler.recover(this, re); 13251 } 13252 finally { 13253 exitRule(); 13254 } 13255 return _localctx; 13256 } 13257 13258 public static class MetaTagContext extends ParserRuleContext { 13259 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13260 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 13261 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13262 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13263 public List<AttributeContext> attribute() { 13264 return getRuleContexts(AttributeContext.class); 13265 } 13266 public AttributeContext attribute(int i) { 13267 return getRuleContext(AttributeContext.class,i); 13268 } 13269 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13270 public TerminalNode NEWLINE(int i) { 13271 return getToken(JavadocParser.NEWLINE, i); 13272 } 13273 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13274 public TerminalNode LEADING_ASTERISK(int i) { 13275 return getToken(JavadocParser.LEADING_ASTERISK, i); 13276 } 13277 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13278 public TerminalNode WS(int i) { 13279 return getToken(JavadocParser.WS, i); 13280 } 13281 public MetaTagContext(ParserRuleContext parent, int invokingState) { 13282 super(parent, invokingState); 13283 } 13284 @Override public int getRuleIndex() { return RULE_metaTag; } 13285 @Override 13286 public void enterRule(ParseTreeListener listener) { 13287 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterMetaTag(this); 13288 } 13289 @Override 13290 public void exitRule(ParseTreeListener listener) { 13291 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitMetaTag(this); 13292 } 13293 @Override 13294 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13295 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitMetaTag(this); 13296 else return visitor.visitChildren(this); 13297 } 13298 } 13299 13300 public final MetaTagContext metaTag() throws RecognitionException { 13301 MetaTagContext _localctx = new MetaTagContext(_ctx, getState()); 13302 enterRule(_localctx, 128, RULE_metaTag); 13303 int _la; 13304 try { 13305 enterOuterAlt(_localctx, 1); 13306 { 13307 setState(1514); 13308 match(OPEN); 13309 setState(1515); 13310 match(META_HTML_TAG_NAME); 13311 setState(1522); 13312 _errHandler.sync(this); 13313 _la = _input.LA(1); 13314 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13315 { 13316 setState(1520); 13317 switch (_input.LA(1)) { 13318 case HTML_TAG_NAME: 13319 { 13320 setState(1516); 13321 attribute(); 13322 } 13323 break; 13324 case NEWLINE: 13325 { 13326 setState(1517); 13327 match(NEWLINE); 13328 } 13329 break; 13330 case LEADING_ASTERISK: 13331 { 13332 setState(1518); 13333 match(LEADING_ASTERISK); 13334 } 13335 break; 13336 case WS: 13337 { 13338 setState(1519); 13339 match(WS); 13340 } 13341 break; 13342 default: 13343 throw new NoViableAltException(this); 13344 } 13345 } 13346 setState(1524); 13347 _errHandler.sync(this); 13348 _la = _input.LA(1); 13349 } 13350 setState(1525); 13351 _la = _input.LA(1); 13352 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13353 _errHandler.recoverInline(this); 13354 } else { 13355 consume(); 13356 } 13357 } 13358 } 13359 catch (RecognitionException re) { 13360 _localctx.exception = re; 13361 _errHandler.reportError(this, re); 13362 _errHandler.recover(this, re); 13363 } 13364 finally { 13365 exitRule(); 13366 } 13367 return _localctx; 13368 } 13369 13370 public static class ParamTagContext extends ParserRuleContext { 13371 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13372 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 13373 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13374 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13375 public List<AttributeContext> attribute() { 13376 return getRuleContexts(AttributeContext.class); 13377 } 13378 public AttributeContext attribute(int i) { 13379 return getRuleContext(AttributeContext.class,i); 13380 } 13381 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13382 public TerminalNode NEWLINE(int i) { 13383 return getToken(JavadocParser.NEWLINE, i); 13384 } 13385 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13386 public TerminalNode LEADING_ASTERISK(int i) { 13387 return getToken(JavadocParser.LEADING_ASTERISK, i); 13388 } 13389 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13390 public TerminalNode WS(int i) { 13391 return getToken(JavadocParser.WS, i); 13392 } 13393 public ParamTagContext(ParserRuleContext parent, int invokingState) { 13394 super(parent, invokingState); 13395 } 13396 @Override public int getRuleIndex() { return RULE_paramTag; } 13397 @Override 13398 public void enterRule(ParseTreeListener listener) { 13399 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParamTag(this); 13400 } 13401 @Override 13402 public void exitRule(ParseTreeListener listener) { 13403 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParamTag(this); 13404 } 13405 @Override 13406 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13407 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParamTag(this); 13408 else return visitor.visitChildren(this); 13409 } 13410 } 13411 13412 public final ParamTagContext paramTag() throws RecognitionException { 13413 ParamTagContext _localctx = new ParamTagContext(_ctx, getState()); 13414 enterRule(_localctx, 130, RULE_paramTag); 13415 int _la; 13416 try { 13417 enterOuterAlt(_localctx, 1); 13418 { 13419 setState(1527); 13420 match(OPEN); 13421 setState(1528); 13422 match(PARAM_HTML_TAG_NAME); 13423 setState(1535); 13424 _errHandler.sync(this); 13425 _la = _input.LA(1); 13426 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13427 { 13428 setState(1533); 13429 switch (_input.LA(1)) { 13430 case HTML_TAG_NAME: 13431 { 13432 setState(1529); 13433 attribute(); 13434 } 13435 break; 13436 case NEWLINE: 13437 { 13438 setState(1530); 13439 match(NEWLINE); 13440 } 13441 break; 13442 case LEADING_ASTERISK: 13443 { 13444 setState(1531); 13445 match(LEADING_ASTERISK); 13446 } 13447 break; 13448 case WS: 13449 { 13450 setState(1532); 13451 match(WS); 13452 } 13453 break; 13454 default: 13455 throw new NoViableAltException(this); 13456 } 13457 } 13458 setState(1537); 13459 _errHandler.sync(this); 13460 _la = _input.LA(1); 13461 } 13462 setState(1538); 13463 _la = _input.LA(1); 13464 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13465 _errHandler.recoverInline(this); 13466 } else { 13467 consume(); 13468 } 13469 } 13470 } 13471 catch (RecognitionException re) { 13472 _localctx.exception = re; 13473 _errHandler.reportError(this, re); 13474 _errHandler.recover(this, re); 13475 } 13476 finally { 13477 exitRule(); 13478 } 13479 return _localctx; 13480 } 13481 13482 public static class WrongSinletonTagContext extends ParserRuleContext { 13483 public SingletonTagNameContext singletonTagName; 13484 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13485 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 13486 public SingletonTagNameContext singletonTagName() { 13487 return getRuleContext(SingletonTagNameContext.class,0); 13488 } 13489 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13490 public WrongSinletonTagContext(ParserRuleContext parent, int invokingState) { 13491 super(parent, invokingState); 13492 } 13493 @Override public int getRuleIndex() { return RULE_wrongSinletonTag; } 13494 @Override 13495 public void enterRule(ParseTreeListener listener) { 13496 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterWrongSinletonTag(this); 13497 } 13498 @Override 13499 public void exitRule(ParseTreeListener listener) { 13500 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitWrongSinletonTag(this); 13501 } 13502 @Override 13503 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13504 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWrongSinletonTag(this); 13505 else return visitor.visitChildren(this); 13506 } 13507 } 13508 13509 public final WrongSinletonTagContext wrongSinletonTag() throws RecognitionException { 13510 WrongSinletonTagContext _localctx = new WrongSinletonTagContext(_ctx, getState()); 13511 enterRule(_localctx, 132, RULE_wrongSinletonTag); 13512 try { 13513 enterOuterAlt(_localctx, 1); 13514 { 13515 setState(1540); 13516 match(OPEN); 13517 setState(1541); 13518 match(SLASH); 13519 setState(1542); 13520 ((WrongSinletonTagContext)_localctx).singletonTagName = singletonTagName(); 13521 setState(1543); 13522 match(CLOSE); 13523 notifyErrorListeners((((WrongSinletonTagContext)_localctx).singletonTagName!=null?(((WrongSinletonTagContext)_localctx).singletonTagName.start):null), "javadoc.wrong.singleton.html.tag", null); 13524 } 13525 } 13526 catch (RecognitionException re) { 13527 _localctx.exception = re; 13528 _errHandler.reportError(this, re); 13529 _errHandler.recover(this, re); 13530 } 13531 finally { 13532 exitRule(); 13533 } 13534 return _localctx; 13535 } 13536 13537 public static class SingletonTagNameContext extends ParserRuleContext { 13538 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 13539 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 13540 public TerminalNode BASEFRONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFRONT_HTML_TAG_NAME, 0); } 13541 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 13542 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 13543 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 13544 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 13545 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 13546 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 13547 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 13548 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 13549 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 13550 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 13551 public SingletonTagNameContext(ParserRuleContext parent, int invokingState) { 13552 super(parent, invokingState); 13553 } 13554 @Override public int getRuleIndex() { return RULE_singletonTagName; } 13555 @Override 13556 public void enterRule(ParseTreeListener listener) { 13557 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTagName(this); 13558 } 13559 @Override 13560 public void exitRule(ParseTreeListener listener) { 13561 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTagName(this); 13562 } 13563 @Override 13564 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13565 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTagName(this); 13566 else return visitor.visitChildren(this); 13567 } 13568 } 13569 13570 public final SingletonTagNameContext singletonTagName() throws RecognitionException { 13571 SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState()); 13572 enterRule(_localctx, 134, RULE_singletonTagName); 13573 int _la; 13574 try { 13575 enterOuterAlt(_localctx, 1); 13576 { 13577 setState(1546); 13578 _la = _input.LA(1); 13579 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)) ) { 13580 _errHandler.recoverInline(this); 13581 } else { 13582 consume(); 13583 } 13584 } 13585 } 13586 catch (RecognitionException re) { 13587 _localctx.exception = re; 13588 _errHandler.reportError(this, re); 13589 _errHandler.recover(this, re); 13590 } 13591 finally { 13592 exitRule(); 13593 } 13594 return _localctx; 13595 } 13596 13597 public static class DescriptionContext extends ParserRuleContext { 13598 public List<HtmlCommentContext> htmlComment() { 13599 return getRuleContexts(HtmlCommentContext.class); 13600 } 13601 public HtmlCommentContext htmlComment(int i) { 13602 return getRuleContext(HtmlCommentContext.class,i); 13603 } 13604 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 13605 public TerminalNode CDATA(int i) { 13606 return getToken(JavadocParser.CDATA, i); 13607 } 13608 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13609 public TerminalNode NEWLINE(int i) { 13610 return getToken(JavadocParser.NEWLINE, i); 13611 } 13612 public List<TextContext> text() { 13613 return getRuleContexts(TextContext.class); 13614 } 13615 public TextContext text(int i) { 13616 return getRuleContext(TextContext.class,i); 13617 } 13618 public List<JavadocInlineTagContext> javadocInlineTag() { 13619 return getRuleContexts(JavadocInlineTagContext.class); 13620 } 13621 public JavadocInlineTagContext javadocInlineTag(int i) { 13622 return getRuleContext(JavadocInlineTagContext.class,i); 13623 } 13624 public List<HtmlElementContext> htmlElement() { 13625 return getRuleContexts(HtmlElementContext.class); 13626 } 13627 public HtmlElementContext htmlElement(int i) { 13628 return getRuleContext(HtmlElementContext.class,i); 13629 } 13630 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13631 public TerminalNode LEADING_ASTERISK(int i) { 13632 return getToken(JavadocParser.LEADING_ASTERISK, i); 13633 } 13634 public DescriptionContext(ParserRuleContext parent, int invokingState) { 13635 super(parent, invokingState); 13636 } 13637 @Override public int getRuleIndex() { return RULE_description; } 13638 @Override 13639 public void enterRule(ParseTreeListener listener) { 13640 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescription(this); 13641 } 13642 @Override 13643 public void exitRule(ParseTreeListener listener) { 13644 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescription(this); 13645 } 13646 @Override 13647 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13648 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this); 13649 else return visitor.visitChildren(this); 13650 } 13651 } 13652 13653 public final DescriptionContext description() throws RecognitionException { 13654 DescriptionContext _localctx = new DescriptionContext(_ctx, getState()); 13655 enterRule(_localctx, 136, RULE_description); 13656 try { 13657 int _alt; 13658 enterOuterAlt(_localctx, 1); 13659 { 13660 setState(1556); 13661 _errHandler.sync(this); 13662 _alt = 1; 13663 do { 13664 switch (_alt) { 13665 case 1: 13666 { 13667 setState(1556); 13668 _errHandler.sync(this); 13669 switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) { 13670 case 1: 13671 { 13672 { 13673 setState(1548); 13674 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 13675 setState(1549); 13676 match(LEADING_ASTERISK); 13677 } 13678 } 13679 break; 13680 case 2: 13681 { 13682 setState(1550); 13683 htmlComment(); 13684 } 13685 break; 13686 case 3: 13687 { 13688 setState(1551); 13689 match(CDATA); 13690 } 13691 break; 13692 case 4: 13693 { 13694 setState(1552); 13695 match(NEWLINE); 13696 } 13697 break; 13698 case 5: 13699 { 13700 setState(1553); 13701 text(); 13702 } 13703 break; 13704 case 6: 13705 { 13706 setState(1554); 13707 javadocInlineTag(); 13708 } 13709 break; 13710 case 7: 13711 { 13712 setState(1555); 13713 htmlElement(); 13714 } 13715 break; 13716 } 13717 } 13718 break; 13719 default: 13720 throw new NoViableAltException(this); 13721 } 13722 setState(1558); 13723 _errHandler.sync(this); 13724 _alt = getInterpreter().adaptivePredict(_input,122,_ctx); 13725 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13726 } 13727 } 13728 catch (RecognitionException re) { 13729 _localctx.exception = re; 13730 _errHandler.reportError(this, re); 13731 _errHandler.recover(this, re); 13732 } 13733 finally { 13734 exitRule(); 13735 } 13736 return _localctx; 13737 } 13738 13739 public static class ReferenceContext extends ParserRuleContext { 13740 public TerminalNode PACKAGE() { return getToken(JavadocParser.PACKAGE, 0); } 13741 public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); } 13742 public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); } 13743 public ParametersContext parameters() { 13744 return getRuleContext(ParametersContext.class,0); 13745 } 13746 public List<TerminalNode> DOT() { return getTokens(JavadocParser.DOT); } 13747 public TerminalNode DOT(int i) { 13748 return getToken(JavadocParser.DOT, i); 13749 } 13750 public List<TerminalNode> CLASS() { return getTokens(JavadocParser.CLASS); } 13751 public TerminalNode CLASS(int i) { 13752 return getToken(JavadocParser.CLASS, i); 13753 } 13754 public ReferenceContext(ParserRuleContext parent, int invokingState) { 13755 super(parent, invokingState); 13756 } 13757 @Override public int getRuleIndex() { return RULE_reference; } 13758 @Override 13759 public void enterRule(ParseTreeListener listener) { 13760 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterReference(this); 13761 } 13762 @Override 13763 public void exitRule(ParseTreeListener listener) { 13764 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitReference(this); 13765 } 13766 @Override 13767 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13768 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitReference(this); 13769 else return visitor.visitChildren(this); 13770 } 13771 } 13772 13773 public final ReferenceContext reference() throws RecognitionException { 13774 ReferenceContext _localctx = new ReferenceContext(_ctx, getState()); 13775 enterRule(_localctx, 138, RULE_reference); 13776 int _la; 13777 try { 13778 int _alt; 13779 enterOuterAlt(_localctx, 1); 13780 { 13781 setState(1597); 13782 switch (_input.LA(1)) { 13783 case PACKAGE: 13784 { 13785 setState(1560); 13786 match(PACKAGE); 13787 setState(1564); 13788 _errHandler.sync(this); 13789 _alt = getInterpreter().adaptivePredict(_input,123,_ctx); 13790 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13791 if ( _alt==1 ) { 13792 { 13793 { 13794 setState(1561); 13795 _la = _input.LA(1); 13796 if ( !(_la==DOT || _la==CLASS) ) { 13797 _errHandler.recoverInline(this); 13798 } else { 13799 consume(); 13800 } 13801 } 13802 } 13803 } 13804 setState(1566); 13805 _errHandler.sync(this); 13806 _alt = getInterpreter().adaptivePredict(_input,123,_ctx); 13807 } 13808 setState(1568); 13809 _errHandler.sync(this); 13810 switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) { 13811 case 1: 13812 { 13813 setState(1567); 13814 match(HASH); 13815 } 13816 break; 13817 } 13818 setState(1571); 13819 _errHandler.sync(this); 13820 switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) { 13821 case 1: 13822 { 13823 setState(1570); 13824 match(MEMBER); 13825 } 13826 break; 13827 } 13828 setState(1574); 13829 _errHandler.sync(this); 13830 switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) { 13831 case 1: 13832 { 13833 setState(1573); 13834 parameters(); 13835 } 13836 break; 13837 } 13838 } 13839 break; 13840 case DOT: 13841 case CLASS: 13842 { 13843 setState(1577); 13844 _errHandler.sync(this); 13845 _alt = 1; 13846 do { 13847 switch (_alt) { 13848 case 1: 13849 { 13850 { 13851 setState(1576); 13852 _la = _input.LA(1); 13853 if ( !(_la==DOT || _la==CLASS) ) { 13854 _errHandler.recoverInline(this); 13855 } else { 13856 consume(); 13857 } 13858 } 13859 } 13860 break; 13861 default: 13862 throw new NoViableAltException(this); 13863 } 13864 setState(1579); 13865 _errHandler.sync(this); 13866 _alt = getInterpreter().adaptivePredict(_input,127,_ctx); 13867 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13868 setState(1582); 13869 _errHandler.sync(this); 13870 switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { 13871 case 1: 13872 { 13873 setState(1581); 13874 match(HASH); 13875 } 13876 break; 13877 } 13878 setState(1585); 13879 _errHandler.sync(this); 13880 switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) { 13881 case 1: 13882 { 13883 setState(1584); 13884 match(MEMBER); 13885 } 13886 break; 13887 } 13888 setState(1588); 13889 _errHandler.sync(this); 13890 switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) { 13891 case 1: 13892 { 13893 setState(1587); 13894 parameters(); 13895 } 13896 break; 13897 } 13898 } 13899 break; 13900 case HASH: 13901 case MEMBER: 13902 { 13903 setState(1591); 13904 _la = _input.LA(1); 13905 if (_la==HASH) { 13906 { 13907 setState(1590); 13908 match(HASH); 13909 } 13910 } 13911 13912 setState(1593); 13913 match(MEMBER); 13914 setState(1595); 13915 _errHandler.sync(this); 13916 switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { 13917 case 1: 13918 { 13919 setState(1594); 13920 parameters(); 13921 } 13922 break; 13923 } 13924 } 13925 break; 13926 default: 13927 throw new NoViableAltException(this); 13928 } 13929 } 13930 } 13931 catch (RecognitionException re) { 13932 _localctx.exception = re; 13933 _errHandler.reportError(this, re); 13934 _errHandler.recover(this, re); 13935 } 13936 finally { 13937 exitRule(); 13938 } 13939 return _localctx; 13940 } 13941 13942 public static class ParametersContext extends ParserRuleContext { 13943 public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); } 13944 public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); } 13945 public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); } 13946 public TerminalNode ARGUMENT(int i) { 13947 return getToken(JavadocParser.ARGUMENT, i); 13948 } 13949 public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); } 13950 public TerminalNode COMMA(int i) { 13951 return getToken(JavadocParser.COMMA, i); 13952 } 13953 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13954 public TerminalNode WS(int i) { 13955 return getToken(JavadocParser.WS, i); 13956 } 13957 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13958 public TerminalNode NEWLINE(int i) { 13959 return getToken(JavadocParser.NEWLINE, i); 13960 } 13961 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13962 public TerminalNode LEADING_ASTERISK(int i) { 13963 return getToken(JavadocParser.LEADING_ASTERISK, i); 13964 } 13965 public ParametersContext(ParserRuleContext parent, int invokingState) { 13966 super(parent, invokingState); 13967 } 13968 @Override public int getRuleIndex() { return RULE_parameters; } 13969 @Override 13970 public void enterRule(ParseTreeListener listener) { 13971 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParameters(this); 13972 } 13973 @Override 13974 public void exitRule(ParseTreeListener listener) { 13975 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParameters(this); 13976 } 13977 @Override 13978 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13979 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParameters(this); 13980 else return visitor.visitChildren(this); 13981 } 13982 } 13983 13984 public final ParametersContext parameters() throws RecognitionException { 13985 ParametersContext _localctx = new ParametersContext(_ctx, getState()); 13986 enterRule(_localctx, 140, RULE_parameters); 13987 int _la; 13988 try { 13989 enterOuterAlt(_localctx, 1); 13990 { 13991 setState(1599); 13992 match(LEFT_BRACE); 13993 setState(1603); 13994 _errHandler.sync(this); 13995 _la = _input.LA(1); 13996 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) { 13997 { 13998 { 13999 setState(1600); 14000 _la = _input.LA(1); 14001 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) { 14002 _errHandler.recoverInline(this); 14003 } else { 14004 consume(); 14005 } 14006 } 14007 } 14008 setState(1605); 14009 _errHandler.sync(this); 14010 _la = _input.LA(1); 14011 } 14012 setState(1606); 14013 match(RIGHT_BRACE); 14014 } 14015 } 14016 catch (RecognitionException re) { 14017 _localctx.exception = re; 14018 _errHandler.reportError(this, re); 14019 _errHandler.recover(this, re); 14020 } 14021 finally { 14022 exitRule(); 14023 } 14024 return _localctx; 14025 } 14026 14027 public static class JavadocTagContext extends ParserRuleContext { 14028 public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); } 14029 public DescriptionContext description() { 14030 return getRuleContext(DescriptionContext.class,0); 14031 } 14032 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14033 public TerminalNode WS(int i) { 14034 return getToken(JavadocParser.WS, i); 14035 } 14036 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14037 public TerminalNode NEWLINE(int i) { 14038 return getToken(JavadocParser.NEWLINE, i); 14039 } 14040 public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); } 14041 public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); } 14042 public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); } 14043 public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); } 14044 public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); } 14045 public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); } 14046 public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); } 14047 public ReferenceContext reference() { 14048 return getRuleContext(ReferenceContext.class,0); 14049 } 14050 public List<TerminalNode> STRING() { return getTokens(JavadocParser.STRING); } 14051 public TerminalNode STRING(int i) { 14052 return getToken(JavadocParser.STRING, i); 14053 } 14054 public List<HtmlElementContext> htmlElement() { 14055 return getRuleContexts(HtmlElementContext.class); 14056 } 14057 public HtmlElementContext htmlElement(int i) { 14058 return getRuleContext(HtmlElementContext.class,i); 14059 } 14060 public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); } 14061 public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); } 14062 public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); } 14063 public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); } 14064 public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); } 14065 public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); } 14066 public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); } 14067 public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); } 14068 public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); } 14069 public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); } 14070 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 14071 public JavadocTagContext(ParserRuleContext parent, int invokingState) { 14072 super(parent, invokingState); 14073 } 14074 @Override public int getRuleIndex() { return RULE_javadocTag; } 14075 @Override 14076 public void enterRule(ParseTreeListener listener) { 14077 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocTag(this); 14078 } 14079 @Override 14080 public void exitRule(ParseTreeListener listener) { 14081 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocTag(this); 14082 } 14083 @Override 14084 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14085 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocTag(this); 14086 else return visitor.visitChildren(this); 14087 } 14088 } 14089 14090 public final JavadocTagContext javadocTag() throws RecognitionException { 14091 JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState()); 14092 enterRule(_localctx, 142, RULE_javadocTag); 14093 int _la; 14094 try { 14095 int _alt; 14096 setState(1802); 14097 switch (_input.LA(1)) { 14098 case AUTHOR_LITERAL: 14099 enterOuterAlt(_localctx, 1); 14100 { 14101 setState(1608); 14102 match(AUTHOR_LITERAL); 14103 setState(1612); 14104 _errHandler.sync(this); 14105 _alt = getInterpreter().adaptivePredict(_input,135,_ctx); 14106 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14107 if ( _alt==1 ) { 14108 { 14109 { 14110 setState(1609); 14111 _la = _input.LA(1); 14112 if ( !(_la==WS || _la==NEWLINE) ) { 14113 _errHandler.recoverInline(this); 14114 } else { 14115 consume(); 14116 } 14117 } 14118 } 14119 } 14120 setState(1614); 14121 _errHandler.sync(this); 14122 _alt = getInterpreter().adaptivePredict(_input,135,_ctx); 14123 } 14124 setState(1616); 14125 _errHandler.sync(this); 14126 switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) { 14127 case 1: 14128 { 14129 setState(1615); 14130 description(); 14131 } 14132 break; 14133 } 14134 } 14135 break; 14136 case DEPRECATED_LITERAL: 14137 enterOuterAlt(_localctx, 2); 14138 { 14139 setState(1618); 14140 match(DEPRECATED_LITERAL); 14141 setState(1622); 14142 _errHandler.sync(this); 14143 _alt = getInterpreter().adaptivePredict(_input,137,_ctx); 14144 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14145 if ( _alt==1 ) { 14146 { 14147 { 14148 setState(1619); 14149 _la = _input.LA(1); 14150 if ( !(_la==WS || _la==NEWLINE) ) { 14151 _errHandler.recoverInline(this); 14152 } else { 14153 consume(); 14154 } 14155 } 14156 } 14157 } 14158 setState(1624); 14159 _errHandler.sync(this); 14160 _alt = getInterpreter().adaptivePredict(_input,137,_ctx); 14161 } 14162 setState(1626); 14163 _errHandler.sync(this); 14164 switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { 14165 case 1: 14166 { 14167 setState(1625); 14168 description(); 14169 } 14170 break; 14171 } 14172 } 14173 break; 14174 case EXCEPTION_LITERAL: 14175 enterOuterAlt(_localctx, 3); 14176 { 14177 setState(1628); 14178 match(EXCEPTION_LITERAL); 14179 setState(1632); 14180 _errHandler.sync(this); 14181 _alt = getInterpreter().adaptivePredict(_input,139,_ctx); 14182 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14183 if ( _alt==1 ) { 14184 { 14185 { 14186 setState(1629); 14187 _la = _input.LA(1); 14188 if ( !(_la==WS || _la==NEWLINE) ) { 14189 _errHandler.recoverInline(this); 14190 } else { 14191 consume(); 14192 } 14193 } 14194 } 14195 } 14196 setState(1634); 14197 _errHandler.sync(this); 14198 _alt = getInterpreter().adaptivePredict(_input,139,_ctx); 14199 } 14200 setState(1636); 14201 _errHandler.sync(this); 14202 switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) { 14203 case 1: 14204 { 14205 setState(1635); 14206 match(CLASS_NAME); 14207 } 14208 break; 14209 } 14210 setState(1641); 14211 _errHandler.sync(this); 14212 _alt = getInterpreter().adaptivePredict(_input,141,_ctx); 14213 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14214 if ( _alt==1 ) { 14215 { 14216 { 14217 setState(1638); 14218 _la = _input.LA(1); 14219 if ( !(_la==WS || _la==NEWLINE) ) { 14220 _errHandler.recoverInline(this); 14221 } else { 14222 consume(); 14223 } 14224 } 14225 } 14226 } 14227 setState(1643); 14228 _errHandler.sync(this); 14229 _alt = getInterpreter().adaptivePredict(_input,141,_ctx); 14230 } 14231 setState(1645); 14232 _errHandler.sync(this); 14233 switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) { 14234 case 1: 14235 { 14236 setState(1644); 14237 description(); 14238 } 14239 break; 14240 } 14241 } 14242 break; 14243 case PARAM_LITERAL: 14244 enterOuterAlt(_localctx, 4); 14245 { 14246 setState(1647); 14247 match(PARAM_LITERAL); 14248 setState(1651); 14249 _errHandler.sync(this); 14250 _alt = getInterpreter().adaptivePredict(_input,143,_ctx); 14251 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14252 if ( _alt==1 ) { 14253 { 14254 { 14255 setState(1648); 14256 _la = _input.LA(1); 14257 if ( !(_la==WS || _la==NEWLINE) ) { 14258 _errHandler.recoverInline(this); 14259 } else { 14260 consume(); 14261 } 14262 } 14263 } 14264 } 14265 setState(1653); 14266 _errHandler.sync(this); 14267 _alt = getInterpreter().adaptivePredict(_input,143,_ctx); 14268 } 14269 setState(1655); 14270 _errHandler.sync(this); 14271 switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { 14272 case 1: 14273 { 14274 setState(1654); 14275 match(PARAMETER_NAME); 14276 } 14277 break; 14278 } 14279 setState(1660); 14280 _errHandler.sync(this); 14281 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 14282 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14283 if ( _alt==1 ) { 14284 { 14285 { 14286 setState(1657); 14287 _la = _input.LA(1); 14288 if ( !(_la==WS || _la==NEWLINE) ) { 14289 _errHandler.recoverInline(this); 14290 } else { 14291 consume(); 14292 } 14293 } 14294 } 14295 } 14296 setState(1662); 14297 _errHandler.sync(this); 14298 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 14299 } 14300 setState(1664); 14301 _errHandler.sync(this); 14302 switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { 14303 case 1: 14304 { 14305 setState(1663); 14306 description(); 14307 } 14308 break; 14309 } 14310 } 14311 break; 14312 case RETURN_LITERAL: 14313 enterOuterAlt(_localctx, 5); 14314 { 14315 setState(1666); 14316 match(RETURN_LITERAL); 14317 setState(1670); 14318 _errHandler.sync(this); 14319 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 14320 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14321 if ( _alt==1 ) { 14322 { 14323 { 14324 setState(1667); 14325 _la = _input.LA(1); 14326 if ( !(_la==WS || _la==NEWLINE) ) { 14327 _errHandler.recoverInline(this); 14328 } else { 14329 consume(); 14330 } 14331 } 14332 } 14333 } 14334 setState(1672); 14335 _errHandler.sync(this); 14336 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 14337 } 14338 setState(1674); 14339 _errHandler.sync(this); 14340 switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { 14341 case 1: 14342 { 14343 setState(1673); 14344 description(); 14345 } 14346 break; 14347 } 14348 } 14349 break; 14350 case SEE_LITERAL: 14351 enterOuterAlt(_localctx, 6); 14352 { 14353 setState(1676); 14354 match(SEE_LITERAL); 14355 setState(1680); 14356 _errHandler.sync(this); 14357 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 14358 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14359 if ( _alt==1 ) { 14360 { 14361 { 14362 setState(1677); 14363 _la = _input.LA(1); 14364 if ( !(_la==WS || _la==NEWLINE) ) { 14365 _errHandler.recoverInline(this); 14366 } else { 14367 consume(); 14368 } 14369 } 14370 } 14371 } 14372 setState(1682); 14373 _errHandler.sync(this); 14374 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 14375 } 14376 setState(1684); 14377 _errHandler.sync(this); 14378 switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { 14379 case 1: 14380 { 14381 setState(1683); 14382 reference(); 14383 } 14384 break; 14385 } 14386 setState(1690); 14387 _errHandler.sync(this); 14388 _alt = getInterpreter().adaptivePredict(_input,152,_ctx); 14389 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14390 if ( _alt==1 ) { 14391 { 14392 setState(1688); 14393 switch (_input.LA(1)) { 14394 case STRING: 14395 { 14396 setState(1686); 14397 match(STRING); 14398 } 14399 break; 14400 case OPEN: 14401 { 14402 setState(1687); 14403 htmlElement(); 14404 } 14405 break; 14406 default: 14407 throw new NoViableAltException(this); 14408 } 14409 } 14410 } 14411 setState(1692); 14412 _errHandler.sync(this); 14413 _alt = getInterpreter().adaptivePredict(_input,152,_ctx); 14414 } 14415 setState(1696); 14416 _errHandler.sync(this); 14417 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 14418 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14419 if ( _alt==1 ) { 14420 { 14421 { 14422 setState(1693); 14423 _la = _input.LA(1); 14424 if ( !(_la==WS || _la==NEWLINE) ) { 14425 _errHandler.recoverInline(this); 14426 } else { 14427 consume(); 14428 } 14429 } 14430 } 14431 } 14432 setState(1698); 14433 _errHandler.sync(this); 14434 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 14435 } 14436 setState(1700); 14437 _errHandler.sync(this); 14438 switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { 14439 case 1: 14440 { 14441 setState(1699); 14442 description(); 14443 } 14444 break; 14445 } 14446 } 14447 break; 14448 case SERIAL_LITERAL: 14449 enterOuterAlt(_localctx, 7); 14450 { 14451 setState(1702); 14452 match(SERIAL_LITERAL); 14453 setState(1706); 14454 _errHandler.sync(this); 14455 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 14456 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14457 if ( _alt==1 ) { 14458 { 14459 { 14460 setState(1703); 14461 _la = _input.LA(1); 14462 if ( !(_la==WS || _la==NEWLINE) ) { 14463 _errHandler.recoverInline(this); 14464 } else { 14465 consume(); 14466 } 14467 } 14468 } 14469 } 14470 setState(1708); 14471 _errHandler.sync(this); 14472 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 14473 } 14474 setState(1710); 14475 _errHandler.sync(this); 14476 switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { 14477 case 1: 14478 { 14479 setState(1709); 14480 _la = _input.LA(1); 14481 if ( !(_la==LITERAL_INCLUDE || _la==LITERAL_EXCLUDE) ) { 14482 _errHandler.recoverInline(this); 14483 } else { 14484 consume(); 14485 } 14486 } 14487 break; 14488 } 14489 setState(1713); 14490 _errHandler.sync(this); 14491 switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { 14492 case 1: 14493 { 14494 setState(1712); 14495 description(); 14496 } 14497 break; 14498 } 14499 } 14500 break; 14501 case SERIAL_DATA_LITERAL: 14502 enterOuterAlt(_localctx, 8); 14503 { 14504 setState(1715); 14505 match(SERIAL_DATA_LITERAL); 14506 setState(1719); 14507 _errHandler.sync(this); 14508 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14509 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14510 if ( _alt==1 ) { 14511 { 14512 { 14513 setState(1716); 14514 _la = _input.LA(1); 14515 if ( !(_la==WS || _la==NEWLINE) ) { 14516 _errHandler.recoverInline(this); 14517 } else { 14518 consume(); 14519 } 14520 } 14521 } 14522 } 14523 setState(1721); 14524 _errHandler.sync(this); 14525 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14526 } 14527 setState(1723); 14528 _errHandler.sync(this); 14529 switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) { 14530 case 1: 14531 { 14532 setState(1722); 14533 description(); 14534 } 14535 break; 14536 } 14537 } 14538 break; 14539 case SERIAL_FIELD_LITERAL: 14540 enterOuterAlt(_localctx, 9); 14541 { 14542 setState(1725); 14543 match(SERIAL_FIELD_LITERAL); 14544 setState(1729); 14545 _errHandler.sync(this); 14546 _alt = getInterpreter().adaptivePredict(_input,160,_ctx); 14547 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14548 if ( _alt==1 ) { 14549 { 14550 { 14551 setState(1726); 14552 _la = _input.LA(1); 14553 if ( !(_la==WS || _la==NEWLINE) ) { 14554 _errHandler.recoverInline(this); 14555 } else { 14556 consume(); 14557 } 14558 } 14559 } 14560 } 14561 setState(1731); 14562 _errHandler.sync(this); 14563 _alt = getInterpreter().adaptivePredict(_input,160,_ctx); 14564 } 14565 setState(1733); 14566 _errHandler.sync(this); 14567 switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) { 14568 case 1: 14569 { 14570 setState(1732); 14571 match(FIELD_NAME); 14572 } 14573 break; 14574 } 14575 setState(1738); 14576 _errHandler.sync(this); 14577 _alt = getInterpreter().adaptivePredict(_input,162,_ctx); 14578 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14579 if ( _alt==1 ) { 14580 { 14581 { 14582 setState(1735); 14583 _la = _input.LA(1); 14584 if ( !(_la==WS || _la==NEWLINE) ) { 14585 _errHandler.recoverInline(this); 14586 } else { 14587 consume(); 14588 } 14589 } 14590 } 14591 } 14592 setState(1740); 14593 _errHandler.sync(this); 14594 _alt = getInterpreter().adaptivePredict(_input,162,_ctx); 14595 } 14596 setState(1742); 14597 _errHandler.sync(this); 14598 switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) { 14599 case 1: 14600 { 14601 setState(1741); 14602 match(FIELD_TYPE); 14603 } 14604 break; 14605 } 14606 setState(1747); 14607 _errHandler.sync(this); 14608 _alt = getInterpreter().adaptivePredict(_input,164,_ctx); 14609 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14610 if ( _alt==1 ) { 14611 { 14612 { 14613 setState(1744); 14614 _la = _input.LA(1); 14615 if ( !(_la==WS || _la==NEWLINE) ) { 14616 _errHandler.recoverInline(this); 14617 } else { 14618 consume(); 14619 } 14620 } 14621 } 14622 } 14623 setState(1749); 14624 _errHandler.sync(this); 14625 _alt = getInterpreter().adaptivePredict(_input,164,_ctx); 14626 } 14627 setState(1751); 14628 _errHandler.sync(this); 14629 switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) { 14630 case 1: 14631 { 14632 setState(1750); 14633 description(); 14634 } 14635 break; 14636 } 14637 } 14638 break; 14639 case SINCE_LITERAL: 14640 enterOuterAlt(_localctx, 10); 14641 { 14642 setState(1753); 14643 match(SINCE_LITERAL); 14644 setState(1757); 14645 _errHandler.sync(this); 14646 _alt = getInterpreter().adaptivePredict(_input,166,_ctx); 14647 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14648 if ( _alt==1 ) { 14649 { 14650 { 14651 setState(1754); 14652 _la = _input.LA(1); 14653 if ( !(_la==WS || _la==NEWLINE) ) { 14654 _errHandler.recoverInline(this); 14655 } else { 14656 consume(); 14657 } 14658 } 14659 } 14660 } 14661 setState(1759); 14662 _errHandler.sync(this); 14663 _alt = getInterpreter().adaptivePredict(_input,166,_ctx); 14664 } 14665 setState(1761); 14666 _errHandler.sync(this); 14667 switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { 14668 case 1: 14669 { 14670 setState(1760); 14671 description(); 14672 } 14673 break; 14674 } 14675 } 14676 break; 14677 case THROWS_LITERAL: 14678 enterOuterAlt(_localctx, 11); 14679 { 14680 setState(1763); 14681 match(THROWS_LITERAL); 14682 setState(1767); 14683 _errHandler.sync(this); 14684 _alt = getInterpreter().adaptivePredict(_input,168,_ctx); 14685 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14686 if ( _alt==1 ) { 14687 { 14688 { 14689 setState(1764); 14690 _la = _input.LA(1); 14691 if ( !(_la==WS || _la==NEWLINE) ) { 14692 _errHandler.recoverInline(this); 14693 } else { 14694 consume(); 14695 } 14696 } 14697 } 14698 } 14699 setState(1769); 14700 _errHandler.sync(this); 14701 _alt = getInterpreter().adaptivePredict(_input,168,_ctx); 14702 } 14703 setState(1771); 14704 _errHandler.sync(this); 14705 switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) { 14706 case 1: 14707 { 14708 setState(1770); 14709 match(CLASS_NAME); 14710 } 14711 break; 14712 } 14713 setState(1776); 14714 _errHandler.sync(this); 14715 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14716 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14717 if ( _alt==1 ) { 14718 { 14719 { 14720 setState(1773); 14721 _la = _input.LA(1); 14722 if ( !(_la==WS || _la==NEWLINE) ) { 14723 _errHandler.recoverInline(this); 14724 } else { 14725 consume(); 14726 } 14727 } 14728 } 14729 } 14730 setState(1778); 14731 _errHandler.sync(this); 14732 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14733 } 14734 setState(1780); 14735 _errHandler.sync(this); 14736 switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) { 14737 case 1: 14738 { 14739 setState(1779); 14740 description(); 14741 } 14742 break; 14743 } 14744 } 14745 break; 14746 case VERSION_LITERAL: 14747 enterOuterAlt(_localctx, 12); 14748 { 14749 setState(1782); 14750 match(VERSION_LITERAL); 14751 setState(1786); 14752 _errHandler.sync(this); 14753 _alt = getInterpreter().adaptivePredict(_input,172,_ctx); 14754 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14755 if ( _alt==1 ) { 14756 { 14757 { 14758 setState(1783); 14759 _la = _input.LA(1); 14760 if ( !(_la==WS || _la==NEWLINE) ) { 14761 _errHandler.recoverInline(this); 14762 } else { 14763 consume(); 14764 } 14765 } 14766 } 14767 } 14768 setState(1788); 14769 _errHandler.sync(this); 14770 _alt = getInterpreter().adaptivePredict(_input,172,_ctx); 14771 } 14772 setState(1790); 14773 _errHandler.sync(this); 14774 switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) { 14775 case 1: 14776 { 14777 setState(1789); 14778 description(); 14779 } 14780 break; 14781 } 14782 } 14783 break; 14784 case CUSTOM_NAME: 14785 enterOuterAlt(_localctx, 13); 14786 { 14787 setState(1792); 14788 match(CUSTOM_NAME); 14789 setState(1796); 14790 _errHandler.sync(this); 14791 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 14792 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14793 if ( _alt==1 ) { 14794 { 14795 { 14796 setState(1793); 14797 _la = _input.LA(1); 14798 if ( !(_la==WS || _la==NEWLINE) ) { 14799 _errHandler.recoverInline(this); 14800 } else { 14801 consume(); 14802 } 14803 } 14804 } 14805 } 14806 setState(1798); 14807 _errHandler.sync(this); 14808 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 14809 } 14810 setState(1800); 14811 _errHandler.sync(this); 14812 switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) { 14813 case 1: 14814 { 14815 setState(1799); 14816 description(); 14817 } 14818 break; 14819 } 14820 } 14821 break; 14822 default: 14823 throw new NoViableAltException(this); 14824 } 14825 } 14826 catch (RecognitionException re) { 14827 _localctx.exception = re; 14828 _errHandler.reportError(this, re); 14829 _errHandler.recover(this, re); 14830 } 14831 finally { 14832 exitRule(); 14833 } 14834 return _localctx; 14835 } 14836 14837 public static class JavadocInlineTagContext extends ParserRuleContext { 14838 public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); } 14839 public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); } 14840 public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); } 14841 public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); } 14842 public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); } 14843 public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); } 14844 public ReferenceContext reference() { 14845 return getRuleContext(ReferenceContext.class,0); 14846 } 14847 public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); } 14848 public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); } 14849 public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); } 14850 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 14851 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14852 public TerminalNode WS(int i) { 14853 return getToken(JavadocParser.WS, i); 14854 } 14855 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14856 public TerminalNode NEWLINE(int i) { 14857 return getToken(JavadocParser.NEWLINE, i); 14858 } 14859 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14860 public TerminalNode LEADING_ASTERISK(int i) { 14861 return getToken(JavadocParser.LEADING_ASTERISK, i); 14862 } 14863 public List<TextContext> text() { 14864 return getRuleContexts(TextContext.class); 14865 } 14866 public TextContext text(int i) { 14867 return getRuleContext(TextContext.class,i); 14868 } 14869 public DescriptionContext description() { 14870 return getRuleContext(DescriptionContext.class,0); 14871 } 14872 public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) { 14873 super(parent, invokingState); 14874 } 14875 @Override public int getRuleIndex() { return RULE_javadocInlineTag; } 14876 @Override 14877 public void enterRule(ParseTreeListener listener) { 14878 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocInlineTag(this); 14879 } 14880 @Override 14881 public void exitRule(ParseTreeListener listener) { 14882 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocInlineTag(this); 14883 } 14884 @Override 14885 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14886 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocInlineTag(this); 14887 else return visitor.visitChildren(this); 14888 } 14889 } 14890 14891 public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException { 14892 JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState()); 14893 enterRule(_localctx, 144, RULE_javadocInlineTag); 14894 int _la; 14895 try { 14896 int _alt; 14897 enterOuterAlt(_localctx, 1); 14898 { 14899 setState(1804); 14900 match(JAVADOC_INLINE_TAG_START); 14901 setState(1880); 14902 switch (_input.LA(1)) { 14903 case CODE_LITERAL: 14904 { 14905 setState(1805); 14906 match(CODE_LITERAL); 14907 setState(1812); 14908 _errHandler.sync(this); 14909 _la = _input.LA(1); 14910 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 14911 { 14912 setState(1810); 14913 _errHandler.sync(this); 14914 switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) { 14915 case 1: 14916 { 14917 setState(1806); 14918 match(WS); 14919 } 14920 break; 14921 case 2: 14922 { 14923 setState(1807); 14924 match(NEWLINE); 14925 } 14926 break; 14927 case 3: 14928 { 14929 setState(1808); 14930 match(LEADING_ASTERISK); 14931 } 14932 break; 14933 case 4: 14934 { 14935 setState(1809); 14936 text(); 14937 } 14938 break; 14939 } 14940 } 14941 setState(1814); 14942 _errHandler.sync(this); 14943 _la = _input.LA(1); 14944 } 14945 } 14946 break; 14947 case DOC_ROOT_LITERAL: 14948 { 14949 setState(1815); 14950 match(DOC_ROOT_LITERAL); 14951 setState(1819); 14952 _errHandler.sync(this); 14953 _la = _input.LA(1); 14954 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 14955 { 14956 { 14957 setState(1816); 14958 _la = _input.LA(1); 14959 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14960 _errHandler.recoverInline(this); 14961 } else { 14962 consume(); 14963 } 14964 } 14965 } 14966 setState(1821); 14967 _errHandler.sync(this); 14968 _la = _input.LA(1); 14969 } 14970 } 14971 break; 14972 case INHERIT_DOC_LITERAL: 14973 { 14974 setState(1822); 14975 match(INHERIT_DOC_LITERAL); 14976 setState(1826); 14977 _errHandler.sync(this); 14978 _la = _input.LA(1); 14979 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 14980 { 14981 { 14982 setState(1823); 14983 _la = _input.LA(1); 14984 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14985 _errHandler.recoverInline(this); 14986 } else { 14987 consume(); 14988 } 14989 } 14990 } 14991 setState(1828); 14992 _errHandler.sync(this); 14993 _la = _input.LA(1); 14994 } 14995 } 14996 break; 14997 case LINK_LITERAL: 14998 { 14999 setState(1829); 15000 match(LINK_LITERAL); 15001 setState(1833); 15002 _errHandler.sync(this); 15003 _la = _input.LA(1); 15004 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15005 { 15006 { 15007 setState(1830); 15008 _la = _input.LA(1); 15009 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15010 _errHandler.recoverInline(this); 15011 } else { 15012 consume(); 15013 } 15014 } 15015 } 15016 setState(1835); 15017 _errHandler.sync(this); 15018 _la = _input.LA(1); 15019 } 15020 setState(1836); 15021 reference(); 15022 setState(1838); 15023 _errHandler.sync(this); 15024 switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { 15025 case 1: 15026 { 15027 setState(1837); 15028 description(); 15029 } 15030 break; 15031 } 15032 } 15033 break; 15034 case LINKPLAIN_LITERAL: 15035 { 15036 setState(1840); 15037 match(LINKPLAIN_LITERAL); 15038 setState(1844); 15039 _errHandler.sync(this); 15040 _la = _input.LA(1); 15041 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15042 { 15043 { 15044 setState(1841); 15045 _la = _input.LA(1); 15046 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15047 _errHandler.recoverInline(this); 15048 } else { 15049 consume(); 15050 } 15051 } 15052 } 15053 setState(1846); 15054 _errHandler.sync(this); 15055 _la = _input.LA(1); 15056 } 15057 setState(1847); 15058 reference(); 15059 setState(1849); 15060 _errHandler.sync(this); 15061 switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) { 15062 case 1: 15063 { 15064 setState(1848); 15065 description(); 15066 } 15067 break; 15068 } 15069 } 15070 break; 15071 case LITERAL_LITERAL: 15072 { 15073 setState(1851); 15074 match(LITERAL_LITERAL); 15075 setState(1858); 15076 _errHandler.sync(this); 15077 _la = _input.LA(1); 15078 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15079 { 15080 setState(1856); 15081 _errHandler.sync(this); 15082 switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) { 15083 case 1: 15084 { 15085 setState(1852); 15086 match(WS); 15087 } 15088 break; 15089 case 2: 15090 { 15091 setState(1853); 15092 match(NEWLINE); 15093 } 15094 break; 15095 case 3: 15096 { 15097 setState(1854); 15098 match(LEADING_ASTERISK); 15099 } 15100 break; 15101 case 4: 15102 { 15103 setState(1855); 15104 text(); 15105 } 15106 break; 15107 } 15108 } 15109 setState(1860); 15110 _errHandler.sync(this); 15111 _la = _input.LA(1); 15112 } 15113 } 15114 break; 15115 case VALUE_LITERAL: 15116 { 15117 setState(1861); 15118 match(VALUE_LITERAL); 15119 setState(1865); 15120 _errHandler.sync(this); 15121 _la = _input.LA(1); 15122 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15123 { 15124 { 15125 setState(1862); 15126 _la = _input.LA(1); 15127 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15128 _errHandler.recoverInline(this); 15129 } else { 15130 consume(); 15131 } 15132 } 15133 } 15134 setState(1867); 15135 _errHandler.sync(this); 15136 _la = _input.LA(1); 15137 } 15138 setState(1869); 15139 _la = _input.LA(1); 15140 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << DOT) | (1L << HASH) | (1L << CLASS) | (1L << MEMBER))) != 0)) { 15141 { 15142 setState(1868); 15143 reference(); 15144 } 15145 } 15146 15147 } 15148 break; 15149 case CUSTOM_NAME: 15150 { 15151 setState(1871); 15152 match(CUSTOM_NAME); 15153 setState(1873); 15154 _errHandler.sync(this); 15155 _alt = 1; 15156 do { 15157 switch (_alt) { 15158 case 1: 15159 { 15160 { 15161 setState(1872); 15162 _la = _input.LA(1); 15163 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15164 _errHandler.recoverInline(this); 15165 } else { 15166 consume(); 15167 } 15168 } 15169 } 15170 break; 15171 default: 15172 throw new NoViableAltException(this); 15173 } 15174 setState(1875); 15175 _errHandler.sync(this); 15176 _alt = getInterpreter().adaptivePredict(_input,189,_ctx); 15177 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15178 setState(1878); 15179 _errHandler.sync(this); 15180 switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) { 15181 case 1: 15182 { 15183 setState(1877); 15184 description(); 15185 } 15186 break; 15187 } 15188 } 15189 break; 15190 default: 15191 throw new NoViableAltException(this); 15192 } 15193 setState(1882); 15194 match(JAVADOC_INLINE_TAG_END); 15195 } 15196 } 15197 catch (RecognitionException re) { 15198 _localctx.exception = re; 15199 _errHandler.reportError(this, re); 15200 _errHandler.recover(this, re); 15201 } 15202 finally { 15203 exitRule(); 15204 } 15205 return _localctx; 15206 } 15207 15208 public static class HtmlCommentContext extends ParserRuleContext { 15209 public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); } 15210 public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); } 15211 public List<TextContext> text() { 15212 return getRuleContexts(TextContext.class); 15213 } 15214 public TextContext text(int i) { 15215 return getRuleContext(TextContext.class,i); 15216 } 15217 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15218 public TerminalNode NEWLINE(int i) { 15219 return getToken(JavadocParser.NEWLINE, i); 15220 } 15221 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15222 public TerminalNode LEADING_ASTERISK(int i) { 15223 return getToken(JavadocParser.LEADING_ASTERISK, i); 15224 } 15225 public HtmlCommentContext(ParserRuleContext parent, int invokingState) { 15226 super(parent, invokingState); 15227 } 15228 @Override public int getRuleIndex() { return RULE_htmlComment; } 15229 @Override 15230 public void enterRule(ParseTreeListener listener) { 15231 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlComment(this); 15232 } 15233 @Override 15234 public void exitRule(ParseTreeListener listener) { 15235 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlComment(this); 15236 } 15237 @Override 15238 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15239 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlComment(this); 15240 else return visitor.visitChildren(this); 15241 } 15242 } 15243 15244 public final HtmlCommentContext htmlComment() throws RecognitionException { 15245 HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState()); 15246 enterRule(_localctx, 146, RULE_htmlComment); 15247 int _la; 15248 try { 15249 enterOuterAlt(_localctx, 1); 15250 { 15251 setState(1884); 15252 match(HTML_COMMENT_START); 15253 setState(1890); 15254 _errHandler.sync(this); 15255 _la = _input.LA(1); 15256 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15257 { 15258 setState(1888); 15259 switch (_input.LA(1)) { 15260 case WS: 15261 case CHAR: 15262 { 15263 setState(1885); 15264 text(); 15265 } 15266 break; 15267 case NEWLINE: 15268 { 15269 setState(1886); 15270 match(NEWLINE); 15271 } 15272 break; 15273 case LEADING_ASTERISK: 15274 { 15275 setState(1887); 15276 match(LEADING_ASTERISK); 15277 } 15278 break; 15279 default: 15280 throw new NoViableAltException(this); 15281 } 15282 } 15283 setState(1892); 15284 _errHandler.sync(this); 15285 _la = _input.LA(1); 15286 } 15287 setState(1893); 15288 match(HTML_COMMENT_END); 15289 } 15290 } 15291 catch (RecognitionException re) { 15292 _localctx.exception = re; 15293 _errHandler.reportError(this, re); 15294 _errHandler.recover(this, re); 15295 } 15296 finally { 15297 exitRule(); 15298 } 15299 return _localctx; 15300 } 15301 15302 public static class TextContext extends ParserRuleContext { 15303 public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); } 15304 public TerminalNode CHAR(int i) { 15305 return getToken(JavadocParser.CHAR, i); 15306 } 15307 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15308 public TerminalNode WS(int i) { 15309 return getToken(JavadocParser.WS, i); 15310 } 15311 public TextContext(ParserRuleContext parent, int invokingState) { 15312 super(parent, invokingState); 15313 } 15314 @Override public int getRuleIndex() { return RULE_text; } 15315 @Override 15316 public void enterRule(ParseTreeListener listener) { 15317 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterText(this); 15318 } 15319 @Override 15320 public void exitRule(ParseTreeListener listener) { 15321 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitText(this); 15322 } 15323 @Override 15324 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15325 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitText(this); 15326 else return visitor.visitChildren(this); 15327 } 15328 } 15329 15330 public final TextContext text() throws RecognitionException { 15331 TextContext _localctx = new TextContext(_ctx, getState()); 15332 enterRule(_localctx, 148, RULE_text); 15333 int _la; 15334 try { 15335 int _alt; 15336 enterOuterAlt(_localctx, 1); 15337 { 15338 setState(1896); 15339 _errHandler.sync(this); 15340 _alt = 1; 15341 do { 15342 switch (_alt) { 15343 case 1: 15344 { 15345 { 15346 setState(1895); 15347 _la = _input.LA(1); 15348 if ( !(_la==WS || _la==CHAR) ) { 15349 _errHandler.recoverInline(this); 15350 } else { 15351 consume(); 15352 } 15353 } 15354 } 15355 break; 15356 default: 15357 throw new NoViableAltException(this); 15358 } 15359 setState(1898); 15360 _errHandler.sync(this); 15361 _alt = getInterpreter().adaptivePredict(_input,194,_ctx); 15362 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15363 } 15364 } 15365 catch (RecognitionException re) { 15366 _localctx.exception = re; 15367 _errHandler.reportError(this, re); 15368 _errHandler.recover(this, re); 15369 } 15370 finally { 15371 exitRule(); 15372 } 15373 return _localctx; 15374 } 15375 15376 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { 15377 switch (ruleIndex) { 15378 case 0: 15379 return javadoc_sempred((JavadocContext)_localctx, predIndex); 15380 case 5: 15381 return htmlTag_sempred((HtmlTagContext)_localctx, predIndex); 15382 case 8: 15383 return paragraph_sempred((ParagraphContext)_localctx, predIndex); 15384 case 11: 15385 return li_sempred((LiContext)_localctx, predIndex); 15386 case 14: 15387 return tr_sempred((TrContext)_localctx, predIndex); 15388 case 17: 15389 return td_sempred((TdContext)_localctx, predIndex); 15390 case 20: 15391 return th_sempred((ThContext)_localctx, predIndex); 15392 case 23: 15393 return body_sempred((BodyContext)_localctx, predIndex); 15394 case 26: 15395 return colgroup_sempred((ColgroupContext)_localctx, predIndex); 15396 case 29: 15397 return dd_sempred((DdContext)_localctx, predIndex); 15398 case 32: 15399 return dt_sempred((DtContext)_localctx, predIndex); 15400 case 35: 15401 return head_sempred((HeadContext)_localctx, predIndex); 15402 case 38: 15403 return html_sempred((HtmlContext)_localctx, predIndex); 15404 case 41: 15405 return option_sempred((OptionContext)_localctx, predIndex); 15406 case 44: 15407 return tbody_sempred((TbodyContext)_localctx, predIndex); 15408 case 47: 15409 return tfoot_sempred((TfootContext)_localctx, predIndex); 15410 case 50: 15411 return thead_sempred((TheadContext)_localctx, predIndex); 15412 case 68: 15413 return description_sempred((DescriptionContext)_localctx, predIndex); 15414 } 15415 return true; 15416 } 15417 private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) { 15418 switch (predIndex) { 15419 case 0: 15420 return !isNextJavadocTag(); 15421 } 15422 return true; 15423 } 15424 private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) { 15425 switch (predIndex) { 15426 case 1: 15427 return !isNextJavadocTag(); 15428 case 2: 15429 return !isNextJavadocTag(); 15430 } 15431 return true; 15432 } 15433 private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) { 15434 switch (predIndex) { 15435 case 3: 15436 return !isNextJavadocTag(); 15437 } 15438 return true; 15439 } 15440 private boolean li_sempred(LiContext _localctx, int predIndex) { 15441 switch (predIndex) { 15442 case 4: 15443 return !isNextJavadocTag(); 15444 } 15445 return true; 15446 } 15447 private boolean tr_sempred(TrContext _localctx, int predIndex) { 15448 switch (predIndex) { 15449 case 5: 15450 return !isNextJavadocTag(); 15451 } 15452 return true; 15453 } 15454 private boolean td_sempred(TdContext _localctx, int predIndex) { 15455 switch (predIndex) { 15456 case 6: 15457 return !isNextJavadocTag(); 15458 } 15459 return true; 15460 } 15461 private boolean th_sempred(ThContext _localctx, int predIndex) { 15462 switch (predIndex) { 15463 case 7: 15464 return !isNextJavadocTag(); 15465 } 15466 return true; 15467 } 15468 private boolean body_sempred(BodyContext _localctx, int predIndex) { 15469 switch (predIndex) { 15470 case 8: 15471 return !isNextJavadocTag(); 15472 } 15473 return true; 15474 } 15475 private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) { 15476 switch (predIndex) { 15477 case 9: 15478 return !isNextJavadocTag(); 15479 } 15480 return true; 15481 } 15482 private boolean dd_sempred(DdContext _localctx, int predIndex) { 15483 switch (predIndex) { 15484 case 10: 15485 return !isNextJavadocTag(); 15486 } 15487 return true; 15488 } 15489 private boolean dt_sempred(DtContext _localctx, int predIndex) { 15490 switch (predIndex) { 15491 case 11: 15492 return !isNextJavadocTag(); 15493 } 15494 return true; 15495 } 15496 private boolean head_sempred(HeadContext _localctx, int predIndex) { 15497 switch (predIndex) { 15498 case 12: 15499 return !isNextJavadocTag(); 15500 } 15501 return true; 15502 } 15503 private boolean html_sempred(HtmlContext _localctx, int predIndex) { 15504 switch (predIndex) { 15505 case 13: 15506 return !isNextJavadocTag(); 15507 } 15508 return true; 15509 } 15510 private boolean option_sempred(OptionContext _localctx, int predIndex) { 15511 switch (predIndex) { 15512 case 14: 15513 return !isNextJavadocTag(); 15514 } 15515 return true; 15516 } 15517 private boolean tbody_sempred(TbodyContext _localctx, int predIndex) { 15518 switch (predIndex) { 15519 case 15: 15520 return !isNextJavadocTag(); 15521 } 15522 return true; 15523 } 15524 private boolean tfoot_sempred(TfootContext _localctx, int predIndex) { 15525 switch (predIndex) { 15526 case 16: 15527 return !isNextJavadocTag(); 15528 } 15529 return true; 15530 } 15531 private boolean thead_sempred(TheadContext _localctx, int predIndex) { 15532 switch (predIndex) { 15533 case 17: 15534 return !isNextJavadocTag(); 15535 } 15536 return true; 15537 } 15538 private boolean description_sempred(DescriptionContext _localctx, int predIndex) { 15539 switch (predIndex) { 15540 case 18: 15541 return !isNextJavadocTag(); 15542 } 15543 return true; 15544 } 15545 15546 public static final String _serializedATN = 15547 "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3]\u076f\4\2\t\2\4"+ 15548 "\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"+ 15549 "\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"+ 15550 "\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"+ 15551 "\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!"+ 15552 "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ 15553 ",\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"+ 15554 "\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="+ 15555 "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ 15556 "\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"+ 15557 "\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"+ 15558 "\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"+ 15559 "\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"+ 15560 "\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"+ 15561 "\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"+ 15562 "\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"+ 15563 "\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"+ 15564 "\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"+ 15565 "\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"+ 15566 "\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"+ 15567 "\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"+ 15568 "\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"+ 15569 "\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"+ 15570 "\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"+ 15571 "\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"+ 15572 "\13\3\13\3\13\3\13\3\13\3\13\7\13\u0180\n\13\f\13\16\13\u0183\13\13\3"+ 15573 "\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"+ 15574 "\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"+ 15575 "\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"+ 15576 "\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"+ 15577 "\3\16\3\16\7\16\u01c5\n\16\f\16\16\16\u01c8\13\16\3\16\3\16\3\17\3\17"+ 15578 "\3\17\3\17\7\17\u01d0\n\17\f\17\16\17\u01d3\13\17\3\17\3\17\3\20\3\20"+ 15579 "\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"+ 15580 "\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"+ 15581 "\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"+ 15582 "\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"+ 15583 "\21\u020d\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0215\n\22\f\22\16"+ 15584 "\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"+ 15585 "\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"+ 15586 "\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"+ 15587 "\3\23\7\23\u0242\n\23\f\23\16\23\u0245\13\23\3\23\3\23\3\24\3\24\3\24"+ 15588 "\3\24\3\24\3\24\7\24\u024f\n\24\f\24\16\24\u0252\13\24\3\24\3\24\3\25"+ 15589 "\3\25\3\25\3\25\7\25\u025a\n\25\f\25\16\25\u025d\13\25\3\25\3\25\3\26"+ 15590 "\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"+ 15591 "\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"+ 15592 "\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"+ 15593 "\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"+ 15594 "\f\27\16\27\u0297\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u029f\n\30"+ 15595 "\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"+ 15596 "\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"+ 15597 "\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"+ 15598 "\31\3\31\3\31\7\31\u02cc\n\31\f\31\16\31\u02cf\13\31\3\31\3\31\3\32\3"+ 15599 "\32\3\32\3\32\3\32\3\32\7\32\u02d9\n\32\f\32\16\32\u02dc\13\32\3\32\3"+ 15600 "\32\3\33\3\33\3\33\3\33\7\33\u02e4\n\33\f\33\16\33\u02e7\13\33\3\33\3"+ 15601 "\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"+ 15602 "\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"+ 15603 "\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"+ 15604 "\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"+ 15605 "\n\35\f\35\16\35\u0321\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0329"+ 15606 "\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"+ 15607 "\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"+ 15608 "\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"+ 15609 "\37\3\37\3\37\3\37\7\37\u0356\n\37\f\37\16\37\u0359\13\37\3\37\3\37\3"+ 15610 " \3 \3 \3 \3 \3 \7 \u0363\n \f \16 \u0366\13 \3 \3 \3!\3!\3!\3!\7!\u036e"+ 15611 "\n!\f!\16!\u0371\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+ 15612 "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+ 15613 "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u039b\n\"\f\"\16\"\u039e\13"+ 15614 "\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u03a8\n#\f#\16#\u03ab\13#\3#\3#\3$\3$"+ 15615 "\3$\3$\7$\u03b3\n$\f$\16$\u03b6\13$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 15616 "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 15617 "%\3%\3%\3%\3%\3%\7%\u03e0\n%\f%\16%\u03e3\13%\3%\3%\3&\3&\3&\3&\3&\3&"+ 15618 "\7&\u03ed\n&\f&\16&\u03f0\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u03f8\n\'\f\'"+ 15619 "\16\'\u03fb\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+ 15620 "\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+ 15621 "\7(\u0425\n(\f(\16(\u0428\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u0432\n)\f)\16"+ 15622 ")\u0435\13)\3)\3)\3*\3*\3*\3*\7*\u043d\n*\f*\16*\u0440\13*\3*\3*\3+\3"+ 15623 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3"+ 15624 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\7+\u046a\n+\f+\16+\u046d\13+"+ 15625 "\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0477\n,\f,\16,\u047a\13,\3,\3,\3-\3-\3-\3"+ 15626 "-\7-\u0482\n-\f-\16-\u0485\13-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+ 15627 "\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+ 15628 "\3.\3.\3.\3.\7.\u04af\n.\f.\16.\u04b2\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u04bc"+ 15629 "\n/\f/\16/\u04bf\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u04c7\n\60\f\60\16"+ 15630 "\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"+ 15631 "\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"+ 15632 "\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"+ 15633 "\3\61\7\61\u04f4\n\61\f\61\16\61\u04f7\13\61\3\61\3\61\3\62\3\62\3\62"+ 15634 "\3\62\3\62\3\62\7\62\u0501\n\62\f\62\16\62\u0504\13\62\3\62\3\62\3\63"+ 15635 "\3\63\3\63\3\63\7\63\u050c\n\63\f\63\16\63\u050f\13\63\3\63\3\63\3\64"+ 15636 "\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"+ 15637 "\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"+ 15638 "\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"+ 15639 "\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"+ 15640 "\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"+ 15641 "\3\66\7\66\u0557\n\66\f\66\16\66\u055a\13\66\3\66\3\66\3\67\3\67\3\67"+ 15642 "\3\67\3\67\3\67\7\67\u0564\n\67\f\67\16\67\u0567\13\67\3\67\3\67\38\3"+ 15643 "8\38\38\38\38\78\u0571\n8\f8\168\u0574\138\38\38\39\39\39\39\39\39\79"+ 15644 "\u057e\n9\f9\169\u0581\139\39\39\3:\3:\3:\3:\3:\3:\7:\u058b\n:\f:\16:"+ 15645 "\u058e\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0598\n;\f;\16;\u059b\13;\3;\3;"+ 15646 "\3<\3<\3<\3<\3<\3<\7<\u05a5\n<\f<\16<\u05a8\13<\3<\3<\3=\3=\3=\3=\3=\3"+ 15647 "=\7=\u05b2\n=\f=\16=\u05b5\13=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u05bf\n>\f>"+ 15648 "\16>\u05c2\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u05cc\n?\f?\16?\u05cf\13?\3"+ 15649 "?\3?\3@\3@\3@\3@\3@\3@\7@\u05d9\n@\f@\16@\u05dc\13@\3@\3@\3A\3A\3A\3A"+ 15650 "\3A\3A\7A\u05e6\nA\fA\16A\u05e9\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u05f3\n"+ 15651 "B\fB\16B\u05f6\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u0600\nC\fC\16C\u0603\13"+ 15652 "C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u0617\nF\r"+ 15653 "F\16F\u0618\3G\3G\7G\u061d\nG\fG\16G\u0620\13G\3G\5G\u0623\nG\3G\5G\u0626"+ 15654 "\nG\3G\5G\u0629\nG\3G\6G\u062c\nG\rG\16G\u062d\3G\5G\u0631\nG\3G\5G\u0634"+ 15655 "\nG\3G\5G\u0637\nG\3G\5G\u063a\nG\3G\3G\5G\u063e\nG\5G\u0640\nG\3H\3H"+ 15656 "\7H\u0644\nH\fH\16H\u0647\13H\3H\3H\3I\3I\7I\u064d\nI\fI\16I\u0650\13"+ 15657 "I\3I\5I\u0653\nI\3I\3I\7I\u0657\nI\fI\16I\u065a\13I\3I\5I\u065d\nI\3I"+ 15658 "\3I\7I\u0661\nI\fI\16I\u0664\13I\3I\5I\u0667\nI\3I\7I\u066a\nI\fI\16I"+ 15659 "\u066d\13I\3I\5I\u0670\nI\3I\3I\7I\u0674\nI\fI\16I\u0677\13I\3I\5I\u067a"+ 15660 "\nI\3I\7I\u067d\nI\fI\16I\u0680\13I\3I\5I\u0683\nI\3I\3I\7I\u0687\nI\f"+ 15661 "I\16I\u068a\13I\3I\5I\u068d\nI\3I\3I\7I\u0691\nI\fI\16I\u0694\13I\3I\5"+ 15662 "I\u0697\nI\3I\3I\7I\u069b\nI\fI\16I\u069e\13I\3I\7I\u06a1\nI\fI\16I\u06a4"+ 15663 "\13I\3I\5I\u06a7\nI\3I\3I\7I\u06ab\nI\fI\16I\u06ae\13I\3I\5I\u06b1\nI"+ 15664 "\3I\5I\u06b4\nI\3I\3I\7I\u06b8\nI\fI\16I\u06bb\13I\3I\5I\u06be\nI\3I\3"+ 15665 "I\7I\u06c2\nI\fI\16I\u06c5\13I\3I\5I\u06c8\nI\3I\7I\u06cb\nI\fI\16I\u06ce"+ 15666 "\13I\3I\5I\u06d1\nI\3I\7I\u06d4\nI\fI\16I\u06d7\13I\3I\5I\u06da\nI\3I"+ 15667 "\3I\7I\u06de\nI\fI\16I\u06e1\13I\3I\5I\u06e4\nI\3I\3I\7I\u06e8\nI\fI\16"+ 15668 "I\u06eb\13I\3I\5I\u06ee\nI\3I\7I\u06f1\nI\fI\16I\u06f4\13I\3I\5I\u06f7"+ 15669 "\nI\3I\3I\7I\u06fb\nI\fI\16I\u06fe\13I\3I\5I\u0701\nI\3I\3I\7I\u0705\n"+ 15670 "I\fI\16I\u0708\13I\3I\5I\u070b\nI\5I\u070d\nI\3J\3J\3J\3J\3J\3J\7J\u0715"+ 15671 "\nJ\fJ\16J\u0718\13J\3J\3J\7J\u071c\nJ\fJ\16J\u071f\13J\3J\3J\7J\u0723"+ 15672 "\nJ\fJ\16J\u0726\13J\3J\3J\7J\u072a\nJ\fJ\16J\u072d\13J\3J\3J\5J\u0731"+ 15673 "\nJ\3J\3J\7J\u0735\nJ\fJ\16J\u0738\13J\3J\3J\5J\u073c\nJ\3J\3J\3J\3J\3"+ 15674 "J\7J\u0743\nJ\fJ\16J\u0746\13J\3J\3J\7J\u074a\nJ\fJ\16J\u074d\13J\3J\5"+ 15675 "J\u0750\nJ\3J\3J\6J\u0754\nJ\rJ\16J\u0755\3J\5J\u0759\nJ\5J\u075b\nJ\3"+ 15676 "J\3J\3K\3K\3K\3K\7K\u0763\nK\fK\16K\u0766\13K\3K\3K\3L\6L\u076b\nL\rL"+ 15677 "\16L\u076c\3L\2\2M\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60"+ 15678 "\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086"+ 15679 "\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\2\13\5\2\3\3\6\6\b\b"+ 15680 "\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"+ 15681 "\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"+ 15682 "\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"+ 15683 "\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"+ 15684 "\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"+ 15685 "\2\2\"\u0210\3\2\2\2$\u021b\3\2\2\2&\u0248\3\2\2\2(\u0255\3\2\2\2*\u0260"+ 15686 "\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"+ 15687 "\2\64\u02df\3\2\2\2\66\u02ea\3\2\2\28\u0317\3\2\2\2:\u0324\3\2\2\2<\u032f"+ 15688 "\3\2\2\2>\u035c\3\2\2\2@\u0369\3\2\2\2B\u0374\3\2\2\2D\u03a1\3\2\2\2F"+ 15689 "\u03ae\3\2\2\2H\u03b9\3\2\2\2J\u03e6\3\2\2\2L\u03f3\3\2\2\2N\u03fe\3\2"+ 15690 "\2\2P\u042b\3\2\2\2R\u0438\3\2\2\2T\u0443\3\2\2\2V\u0470\3\2\2\2X\u047d"+ 15691 "\3\2\2\2Z\u0488\3\2\2\2\\\u04b5\3\2\2\2^\u04c2\3\2\2\2`\u04cd\3\2\2\2"+ 15692 "b\u04fa\3\2\2\2d\u0507\3\2\2\2f\u0512\3\2\2\2h\u054e\3\2\2\2j\u0550\3"+ 15693 "\2\2\2l\u055d\3\2\2\2n\u056a\3\2\2\2p\u0577\3\2\2\2r\u0584\3\2\2\2t\u0591"+ 15694 "\3\2\2\2v\u059e\3\2\2\2x\u05ab\3\2\2\2z\u05b8\3\2\2\2|\u05c5\3\2\2\2~"+ 15695 "\u05d2\3\2\2\2\u0080\u05df\3\2\2\2\u0082\u05ec\3\2\2\2\u0084\u05f9\3\2"+ 15696 "\2\2\u0086\u0606\3\2\2\2\u0088\u060c\3\2\2\2\u008a\u0616\3\2\2\2\u008c"+ 15697 "\u063f\3\2\2\2\u008e\u0641\3\2\2\2\u0090\u070c\3\2\2\2\u0092\u070e\3\2"+ 15698 "\2\2\u0094\u075e\3\2\2\2\u0096\u076a\3\2\2\2\u0098\u00a1\5\4\3\2\u0099"+ 15699 "\u009a\6\2\2\2\u009a\u00a1\7\3\2\2\u009b\u00a1\5\u0094K\2\u009c\u00a1"+ 15700 "\7\5\2\2\u009d\u00a1\7\b\2\2\u009e\u00a1\5\u0096L\2\u009f\u00a1\5\u0092"+ 15701 "J\2\u00a0\u0098\3\2\2\2\u00a0\u0099\3\2\2\2\u00a0\u009b\3\2\2\2\u00a0"+ 15702 "\u009c\3\2\2\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u009f\3\2"+ 15703 "\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3"+ 15704 "\u00b1\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a7\7\3\2\2\u00a6\u00a5\3\2"+ 15705 "\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00ab\3\2\2\2\u00a8\u00aa\7\6\2\2\u00a9"+ 15706 "\u00a8\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2"+ 15707 "\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00b0\5\u0090I\2\u00af"+ 15708 "\u00a6\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2"+ 15709 "\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5\7\2\2\3\u00b5"+ 15710 "\3\3\2\2\2\u00b6\u00e6\5\f\7\2\u00b7\u00e6\5h\65\2\u00b8\u00e6\5\22\n"+ 15711 "\2\u00b9\u00e6\5\30\r\2\u00ba\u00e6\5\36\20\2\u00bb\u00e6\5$\23\2\u00bc"+ 15712 "\u00e6\5*\26\2\u00bd\u00e6\5\60\31\2\u00be\u00e6\5\66\34\2\u00bf\u00e6"+ 15713 "\5<\37\2\u00c0\u00e6\5B\"\2\u00c1\u00e6\5H%\2\u00c2\u00e6\5N(\2\u00c3"+ 15714 "\u00e6\5T+\2\u00c4\u00e6\5Z.\2\u00c5\u00e6\5f\64\2\u00c6\u00e6\5`\61\2"+ 15715 "\u00c7\u00e6\5\16\b\2\u00c8\u00e6\5\24\13\2\u00c9\u00e6\5\32\16\2\u00ca"+ 15716 "\u00e6\5 \21\2\u00cb\u00e6\5&\24\2\u00cc\u00e6\5,\27\2\u00cd\u00e6\5\62"+ 15717 "\32\2\u00ce\u00e6\58\35\2\u00cf\u00e6\5> \2\u00d0\u00e6\5D#\2\u00d1\u00e6"+ 15718 "\5J&\2\u00d2\u00e6\5P)\2\u00d3\u00e6\5V,\2\u00d4\u00e6\5b\62\2\u00d5\u00e6"+ 15719 "\5\\/\2\u00d6\u00e6\5\20\t\2\u00d7\u00e6\5\26\f\2\u00d8\u00e6\5\34\17"+ 15720 "\2\u00d9\u00e6\5\"\22\2\u00da\u00e6\5(\25\2\u00db\u00e6\5.\30\2\u00dc"+ 15721 "\u00e6\5\64\33\2\u00dd\u00e6\5:\36\2\u00de\u00e6\5@!\2\u00df\u00e6\5F"+ 15722 "$\2\u00e0\u00e6\5L\'\2\u00e1\u00e6\5R*\2\u00e2\u00e6\5X-\2\u00e3\u00e6"+ 15723 "\5d\63\2\u00e4\u00e6\5^\60\2\u00e5\u00b6\3\2\2\2\u00e5\u00b7\3\2\2\2\u00e5"+ 15724 "\u00b8\3\2\2\2\u00e5\u00b9\3\2\2\2\u00e5\u00ba\3\2\2\2\u00e5\u00bb\3\2"+ 15725 "\2\2\u00e5\u00bc\3\2\2\2\u00e5\u00bd\3\2\2\2\u00e5\u00be\3\2\2\2\u00e5"+ 15726 "\u00bf\3\2\2\2\u00e5\u00c0\3\2\2\2\u00e5\u00c1\3\2\2\2\u00e5\u00c2\3\2"+ 15727 "\2\2\u00e5\u00c3\3\2\2\2\u00e5\u00c4\3\2\2\2\u00e5\u00c5\3\2\2\2\u00e5"+ 15728 "\u00c6\3\2\2\2\u00e5\u00c7\3\2\2\2\u00e5\u00c8\3\2\2\2\u00e5\u00c9\3\2"+ 15729 "\2\2\u00e5\u00ca\3\2\2\2\u00e5\u00cb\3\2\2\2\u00e5\u00cc\3\2\2\2\u00e5"+ 15730 "\u00cd\3\2\2\2\u00e5\u00ce\3\2\2\2\u00e5\u00cf\3\2\2\2\u00e5\u00d0\3\2"+ 15731 "\2\2\u00e5\u00d1\3\2\2\2\u00e5\u00d2\3\2\2\2\u00e5\u00d3\3\2\2\2\u00e5"+ 15732 "\u00d4\3\2\2\2\u00e5\u00d5\3\2\2\2\u00e5\u00d6\3\2\2\2\u00e5\u00d7\3\2"+ 15733 "\2\2\u00e5\u00d8\3\2\2\2\u00e5\u00d9\3\2\2\2\u00e5\u00da\3\2\2\2\u00e5"+ 15734 "\u00db\3\2\2\2\u00e5\u00dc\3\2\2\2\u00e5\u00dd\3\2\2\2\u00e5\u00de\3\2"+ 15735 "\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2\u00e5\u00e1\3\2\2\2\u00e5"+ 15736 "\u00e2\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4\3\2\2\2\u00e6\5\3\2\2\2"+ 15737 "\u00e7\u00e8\7\7\2\2\u00e8\u00ef\7Y\2\2\u00e9\u00ee\5\n\6\2\u00ea\u00ee"+ 15738 "\7\b\2\2\u00eb\u00ee\7\3\2\2\u00ec\u00ee\7\6\2\2\u00ed\u00e9\3\2\2\2\u00ed"+ 15739 "\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec\3\2\2\2\u00ee\u00f1\3\2"+ 15740 "\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\3\2\2\2\u00f1"+ 15741 "\u00ef\3\2\2\2\u00f2\u00f3\79\2\2\u00f3\7\3\2\2\2\u00f4\u00f5\7\7\2\2"+ 15742 "\u00f5\u00f6\7;\2\2\u00f6\u00fa\7Y\2\2\u00f7\u00f9\t\2\2\2\u00f8\u00f7"+ 15743 "\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb"+ 15744 "\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\79\2\2\u00fe\t\3\2\2\2"+ 15745 "\u00ff\u0103\7Y\2\2\u0100\u0102\t\2\2\2\u0101\u0100\3\2\2\2\u0102\u0105"+ 15746 "\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105"+ 15747 "\u0103\3\2\2\2\u0106\u010a\7<\2\2\u0107\u0109\t\2\2\2\u0108\u0107\3\2"+ 15748 "\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b"+ 15749 "\u0110\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0111\7[\2\2\u010e\u0111\5\u0096"+ 15750 "L\2\u010f\u0111\7Y\2\2\u0110\u010d\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u010f"+ 15751 "\3\2\2\2\u0111\13\3\2\2\2\u0112\u011d\5\6\4\2\u0113\u011c\5\4\3\2\u0114"+ 15752 "\u0115\6\7\3\2\u0115\u011c\7\3\2\2\u0116\u011c\5\u0094K\2\u0117\u011c"+ 15753 "\7\5\2\2\u0118\u011c\7\b\2\2\u0119\u011c\5\u0096L\2\u011a\u011c\5\u0092"+ 15754 "J\2\u011b\u0113\3\2\2\2\u011b\u0114\3\2\2\2\u011b\u0116\3\2\2\2\u011b"+ 15755 "\u0117\3\2\2\2\u011b\u0118\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2"+ 15756 "\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+ 15757 "\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\5\b\5\2\u0121\u0133\3\2"+ 15758 "\2\2\u0122\u012d\5\6\4\2\u0123\u012c\5\4\3\2\u0124\u0125\6\7\4\2\u0125"+ 15759 "\u012c\7\3\2\2\u0126\u012c\5\u0094K\2\u0127\u012c\7\5\2\2\u0128\u012c"+ 15760 "\7\b\2\2\u0129\u012c\5\u0096L\2\u012a\u012c\5\u0092J\2\u012b\u0123\3\2"+ 15761 "\2\2\u012b\u0124\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012b"+ 15762 "\u0128\3\2\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f\3\2"+ 15763 "\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0130\3\2\2\2\u012f"+ 15764 "\u012d\3\2\2\2\u0130\u0131\b\7\1\2\u0131\u0133\3\2\2\2\u0132\u0112\3\2"+ 15765 "\2\2\u0132\u0122\3\2\2\2\u0133\r\3\2\2\2\u0134\u0135\7\7\2\2\u0135\u013c"+ 15766 "\7=\2\2\u0136\u013b\5\n\6\2\u0137\u013b\7\b\2\2\u0138\u013b\7\3\2\2\u0139"+ 15767 "\u013b\7\6\2\2\u013a\u0136\3\2\2\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2"+ 15768 "\2\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+ 15769 "\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0140\79"+ 15770 "\2\2\u0140\17\3\2\2\2\u0141\u0142\7\7\2\2\u0142\u0143\7;\2\2\u0143\u0147"+ 15771 "\7=\2\2\u0144\u0146\t\2\2\2\u0145\u0144\3\2\2\2\u0146\u0149\3\2\2\2\u0147"+ 15772 "\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2\u0149\u0147\3\2"+ 15773 "\2\2\u014a\u014b\79\2\2\u014b\21\3\2\2\2\u014c\u0174\5\16\b\2\u014d\u0173"+ 15774 "\5\f\7\2\u014e\u0173\5j\66\2\u014f\u0173\5\30\r\2\u0150\u0173\5\36\20"+ 15775 "\2\u0151\u0173\5$\23\2\u0152\u0173\5*\26\2\u0153\u0173\5\60\31\2\u0154"+ 15776 "\u0173\5\66\34\2\u0155\u0173\5<\37\2\u0156\u0173\5B\"\2\u0157\u0173\5"+ 15777 "H%\2\u0158\u0173\5N(\2\u0159\u0173\5T+\2\u015a\u0173\5Z.\2\u015b\u0173"+ 15778 "\5f\64\2\u015c\u0173\5`\61\2\u015d\u0173\5\24\13\2\u015e\u0173\5\32\16"+ 15779 "\2\u015f\u0173\5 \21\2\u0160\u0173\5&\24\2\u0161\u0173\5,\27\2\u0162\u0173"+ 15780 "\5\62\32\2\u0163\u0173\58\35\2\u0164\u0173\5> \2\u0165\u0173\5D#\2\u0166"+ 15781 "\u0173\5J&\2\u0167\u0173\5P)\2\u0168\u0173\5V,\2\u0169\u0173\5b\62\2\u016a"+ 15782 "\u0173\5\\/\2\u016b\u016c\6\n\5\2\u016c\u0173\7\3\2\2\u016d\u0173\5\u0094"+ 15783 "K\2\u016e\u0173\7\5\2\2\u016f\u0173\7\b\2\2\u0170\u0173\5\u0096L\2\u0171"+ 15784 "\u0173\5\u0092J\2\u0172\u014d\3\2\2\2\u0172\u014e\3\2\2\2\u0172\u014f"+ 15785 "\3\2\2\2\u0172\u0150\3\2\2\2\u0172\u0151\3\2\2\2\u0172\u0152\3\2\2\2\u0172"+ 15786 "\u0153\3\2\2\2\u0172\u0154\3\2\2\2\u0172\u0155\3\2\2\2\u0172\u0156\3\2"+ 15787 "\2\2\u0172\u0157\3\2\2\2\u0172\u0158\3\2\2\2\u0172\u0159\3\2\2\2\u0172"+ 15788 "\u015a\3\2\2\2\u0172\u015b\3\2\2\2\u0172\u015c\3\2\2\2\u0172\u015d\3\2"+ 15789 "\2\2\u0172\u015e\3\2\2\2\u0172\u015f\3\2\2\2\u0172\u0160\3\2\2\2\u0172"+ 15790 "\u0161\3\2\2\2\u0172\u0162\3\2\2\2\u0172\u0163\3\2\2\2\u0172\u0164\3\2"+ 15791 "\2\2\u0172\u0165\3\2\2\2\u0172\u0166\3\2\2\2\u0172\u0167\3\2\2\2\u0172"+ 15792 "\u0168\3\2\2\2\u0172\u0169\3\2\2\2\u0172\u016a\3\2\2\2\u0172\u016b\3\2"+ 15793 "\2\2\u0172\u016d\3\2\2\2\u0172\u016e\3\2\2\2\u0172\u016f\3\2\2\2\u0172"+ 15794 "\u0170\3\2\2\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2"+ 15795 "\2\2\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177"+ 15796 "\u0178\5\20\t\2\u0178\23\3\2\2\2\u0179\u017a\7\7\2\2\u017a\u0181\7>\2"+ 15797 "\2\u017b\u0180\5\n\6\2\u017c\u0180\7\b\2\2\u017d\u0180\7\3\2\2\u017e\u0180"+ 15798 "\7\6\2\2\u017f\u017b\3\2\2\2\u017f\u017c\3\2\2\2\u017f\u017d\3\2\2\2\u017f"+ 15799 "\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+ 15800 "\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\79\2\2\u0185"+ 15801 "\25\3\2\2\2\u0186\u0187\7\7\2\2\u0187\u0188\7;\2\2\u0188\u018c\7>\2\2"+ 15802 "\u0189\u018b\t\2\2\2\u018a\u0189\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a"+ 15803 "\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f"+ 15804 "\u0190\79\2\2\u0190\27\3\2\2\2\u0191\u01b9\5\24\13\2\u0192\u01b8\5\f\7"+ 15805 "\2\u0193\u01b8\5j\66\2\u0194\u01b8\5\22\n\2\u0195\u01b8\5\36\20\2\u0196"+ 15806 "\u01b8\5$\23\2\u0197\u01b8\5*\26\2\u0198\u01b8\5\60\31\2\u0199\u01b8\5"+ 15807 "\66\34\2\u019a\u01b8\5<\37\2\u019b\u01b8\5B\"\2\u019c\u01b8\5H%\2\u019d"+ 15808 "\u01b8\5N(\2\u019e\u01b8\5T+\2\u019f\u01b8\5Z.\2\u01a0\u01b8\5f\64\2\u01a1"+ 15809 "\u01b8\5`\61\2\u01a2\u01b8\5\16\b\2\u01a3\u01b8\5\32\16\2\u01a4\u01b8"+ 15810 "\5 \21\2\u01a5\u01b8\5&\24\2\u01a6\u01b8\5,\27\2\u01a7\u01b8\5\62\32\2"+ 15811 "\u01a8\u01b8\58\35\2\u01a9\u01b8\5> \2\u01aa\u01b8\5D#\2\u01ab\u01b8\5"+ 15812 "J&\2\u01ac\u01b8\5P)\2\u01ad\u01b8\5V,\2\u01ae\u01b8\5b\62\2\u01af\u01b8"+ 15813 "\5\\/\2\u01b0\u01b1\6\r\6\2\u01b1\u01b8\7\3\2\2\u01b2\u01b8\5\u0094K\2"+ 15814 "\u01b3\u01b8\7\5\2\2\u01b4\u01b8\7\b\2\2\u01b5\u01b8\5\u0096L\2\u01b6"+ 15815 "\u01b8\5\u0092J\2\u01b7\u0192\3\2\2\2\u01b7\u0193\3\2\2\2\u01b7\u0194"+ 15816 "\3\2\2\2\u01b7\u0195\3\2\2\2\u01b7\u0196\3\2\2\2\u01b7\u0197\3\2\2\2\u01b7"+ 15817 "\u0198\3\2\2\2\u01b7\u0199\3\2\2\2\u01b7\u019a\3\2\2\2\u01b7\u019b\3\2"+ 15818 "\2\2\u01b7\u019c\3\2\2\2\u01b7\u019d\3\2\2\2\u01b7\u019e\3\2\2\2\u01b7"+ 15819 "\u019f\3\2\2\2\u01b7\u01a0\3\2\2\2\u01b7\u01a1\3\2\2\2\u01b7\u01a2\3\2"+ 15820 "\2\2\u01b7\u01a3\3\2\2\2\u01b7\u01a4\3\2\2\2\u01b7\u01a5\3\2\2\2\u01b7"+ 15821 "\u01a6\3\2\2\2\u01b7\u01a7\3\2\2\2\u01b7\u01a8\3\2\2\2\u01b7\u01a9\3\2"+ 15822 "\2\2\u01b7\u01aa\3\2\2\2\u01b7\u01ab\3\2\2\2\u01b7\u01ac\3\2\2\2\u01b7"+ 15823 "\u01ad\3\2\2\2\u01b7\u01ae\3\2\2\2\u01b7\u01af\3\2\2\2\u01b7\u01b0\3\2"+ 15824 "\2\2\u01b7\u01b2\3\2\2\2\u01b7\u01b3\3\2\2\2\u01b7\u01b4\3\2\2\2\u01b7"+ 15825 "\u01b5\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2"+ 15826 "\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc"+ 15827 "\u01bd\5\26\f\2\u01bd\31\3\2\2\2\u01be\u01bf\7\7\2\2\u01bf\u01c6\7?\2"+ 15828 "\2\u01c0\u01c5\5\n\6\2\u01c1\u01c5\7\b\2\2\u01c2\u01c5\7\3\2\2\u01c3\u01c5"+ 15829 "\7\6\2\2\u01c4\u01c0\3\2\2\2\u01c4\u01c1\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c4"+ 15830 "\u01c3\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2"+ 15831 "\2\2\u01c7\u01c9\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\79\2\2\u01ca"+ 15832 "\33\3\2\2\2\u01cb\u01cc\7\7\2\2\u01cc\u01cd\7;\2\2\u01cd\u01d1\7?\2\2"+ 15833 "\u01ce\u01d0\t\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+ 15834 "\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d4\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+ 15835 "\u01d5\79\2\2\u01d5\35\3\2\2\2\u01d6\u01fe\5\32\16\2\u01d7\u01fd\5\f\7"+ 15836 "\2\u01d8\u01fd\5j\66\2\u01d9\u01fd\5\22\n\2\u01da\u01fd\5\30\r\2\u01db"+ 15837 "\u01fd\5$\23\2\u01dc\u01fd\5*\26\2\u01dd\u01fd\5\60\31\2\u01de\u01fd\5"+ 15838 "\66\34\2\u01df\u01fd\5<\37\2\u01e0\u01fd\5B\"\2\u01e1\u01fd\5H%\2\u01e2"+ 15839 "\u01fd\5N(\2\u01e3\u01fd\5T+\2\u01e4\u01fd\5Z.\2\u01e5\u01fd\5f\64\2\u01e6"+ 15840 "\u01fd\5`\61\2\u01e7\u01fd\5\16\b\2\u01e8\u01fd\5\24\13\2\u01e9\u01fd"+ 15841 "\5 \21\2\u01ea\u01fd\5&\24\2\u01eb\u01fd\5,\27\2\u01ec\u01fd\5\62\32\2"+ 15842 "\u01ed\u01fd\58\35\2\u01ee\u01fd\5> \2\u01ef\u01fd\5D#\2\u01f0\u01fd\5"+ 15843 "J&\2\u01f1\u01fd\5P)\2\u01f2\u01fd\5V,\2\u01f3\u01fd\5b\62\2\u01f4\u01fd"+ 15844 "\5\\/\2\u01f5\u01f6\6\20\7\2\u01f6\u01fd\7\3\2\2\u01f7\u01fd\5\u0094K"+ 15845 "\2\u01f8\u01fd\7\5\2\2\u01f9\u01fd\7\b\2\2\u01fa\u01fd\5\u0096L\2\u01fb"+ 15846 "\u01fd\5\u0092J\2\u01fc\u01d7\3\2\2\2\u01fc\u01d8\3\2\2\2\u01fc\u01d9"+ 15847 "\3\2\2\2\u01fc\u01da\3\2\2\2\u01fc\u01db\3\2\2\2\u01fc\u01dc\3\2\2\2\u01fc"+ 15848 "\u01dd\3\2\2\2\u01fc\u01de\3\2\2\2\u01fc\u01df\3\2\2\2\u01fc\u01e0\3\2"+ 15849 "\2\2\u01fc\u01e1\3\2\2\2\u01fc\u01e2\3\2\2\2\u01fc\u01e3\3\2\2\2\u01fc"+ 15850 "\u01e4\3\2\2\2\u01fc\u01e5\3\2\2\2\u01fc\u01e6\3\2\2\2\u01fc\u01e7\3\2"+ 15851 "\2\2\u01fc\u01e8\3\2\2\2\u01fc\u01e9\3\2\2\2\u01fc\u01ea\3\2\2\2\u01fc"+ 15852 "\u01eb\3\2\2\2\u01fc\u01ec\3\2\2\2\u01fc\u01ed\3\2\2\2\u01fc\u01ee\3\2"+ 15853 "\2\2\u01fc\u01ef\3\2\2\2\u01fc\u01f0\3\2\2\2\u01fc\u01f1\3\2\2\2\u01fc"+ 15854 "\u01f2\3\2\2\2\u01fc\u01f3\3\2\2\2\u01fc\u01f4\3\2\2\2\u01fc\u01f5\3\2"+ 15855 "\2\2\u01fc\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc"+ 15856 "\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2"+ 15857 "\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201\3\2\2\2\u0200\u01fe\3\2\2\2\u0201"+ 15858 "\u0202\5\34\17\2\u0202\37\3\2\2\2\u0203\u0204\7\7\2\2\u0204\u020b\7@\2"+ 15859 "\2\u0205\u020a\5\n\6\2\u0206\u020a\7\b\2\2\u0207\u020a\7\3\2\2\u0208\u020a"+ 15860 "\7\6\2\2\u0209\u0205\3\2\2\2\u0209\u0206\3\2\2\2\u0209\u0207\3\2\2\2\u0209"+ 15861 "\u0208\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2"+ 15862 "\2\2\u020c\u020e\3\2\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f"+ 15863 "!\3\2\2\2\u0210\u0211\7\7\2\2\u0211\u0212\7;\2\2\u0212\u0216\7@\2\2\u0213"+ 15864 "\u0215\t\2\2\2\u0214\u0213\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2"+ 15865 "\2\2\u0216\u0217\3\2\2\2\u0217\u0219\3\2\2\2\u0218\u0216\3\2\2\2\u0219"+ 15866 "\u021a\79\2\2\u021a#\3\2\2\2\u021b\u0243\5 \21\2\u021c\u0242\5\f\7\2\u021d"+ 15867 "\u0242\5j\66\2\u021e\u0242\5\22\n\2\u021f\u0242\5\30\r\2\u0220\u0242\5"+ 15868 "\36\20\2\u0221\u0242\5*\26\2\u0222\u0242\5\60\31\2\u0223\u0242\5\66\34"+ 15869 "\2\u0224\u0242\5<\37\2\u0225\u0242\5B\"\2\u0226\u0242\5H%\2\u0227\u0242"+ 15870 "\5N(\2\u0228\u0242\5T+\2\u0229\u0242\5Z.\2\u022a\u0242\5f\64\2\u022b\u0242"+ 15871 "\5`\61\2\u022c\u0242\5\16\b\2\u022d\u0242\5\24\13\2\u022e\u0242\5 \21"+ 15872 "\2\u022f\u0242\5&\24\2\u0230\u0242\5,\27\2\u0231\u0242\5\62\32\2\u0232"+ 15873 "\u0242\58\35\2\u0233\u0242\5> \2\u0234\u0242\5D#\2\u0235\u0242\5J&\2\u0236"+ 15874 "\u0242\5P)\2\u0237\u0242\5V,\2\u0238\u0242\5b\62\2\u0239\u0242\5\\/\2"+ 15875 "\u023a\u023b\6\23\b\2\u023b\u0242\7\3\2\2\u023c\u0242\5\u0094K\2\u023d"+ 15876 "\u0242\7\5\2\2\u023e\u0242\7\b\2\2\u023f\u0242\5\u0096L\2\u0240\u0242"+ 15877 "\5\u0092J\2\u0241\u021c\3\2\2\2\u0241\u021d\3\2\2\2\u0241\u021e\3\2\2"+ 15878 "\2\u0241\u021f\3\2\2\2\u0241\u0220\3\2\2\2\u0241\u0221\3\2\2\2\u0241\u0222"+ 15879 "\3\2\2\2\u0241\u0223\3\2\2\2\u0241\u0224\3\2\2\2\u0241\u0225\3\2\2\2\u0241"+ 15880 "\u0226\3\2\2\2\u0241\u0227\3\2\2\2\u0241\u0228\3\2\2\2\u0241\u0229\3\2"+ 15881 "\2\2\u0241\u022a\3\2\2\2\u0241\u022b\3\2\2\2\u0241\u022c\3\2\2\2\u0241"+ 15882 "\u022d\3\2\2\2\u0241\u022e\3\2\2\2\u0241\u022f\3\2\2\2\u0241\u0230\3\2"+ 15883 "\2\2\u0241\u0231\3\2\2\2\u0241\u0232\3\2\2\2\u0241\u0233\3\2\2\2\u0241"+ 15884 "\u0234\3\2\2\2\u0241\u0235\3\2\2\2\u0241\u0236\3\2\2\2\u0241\u0237\3\2"+ 15885 "\2\2\u0241\u0238\3\2\2\2\u0241\u0239\3\2\2\2\u0241\u023a\3\2\2\2\u0241"+ 15886 "\u023c\3\2\2\2\u0241\u023d\3\2\2\2\u0241\u023e\3\2\2\2\u0241\u023f\3\2"+ 15887 "\2\2\u0241\u0240\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243"+ 15888 "\u0244\3\2\2\2\u0244\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\5\""+ 15889 "\22\2\u0247%\3\2\2\2\u0248\u0249\7\7\2\2\u0249\u0250\7A\2\2\u024a\u024f"+ 15890 "\5\n\6\2\u024b\u024f\7\b\2\2\u024c\u024f\7\3\2\2\u024d\u024f\7\6\2\2\u024e"+ 15891 "\u024a\3\2\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2"+ 15892 "\2\2\u024f\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251"+ 15893 "\u0253\3\2\2\2\u0252\u0250\3\2\2\2\u0253\u0254\79\2\2\u0254\'\3\2\2\2"+ 15894 "\u0255\u0256\7\7\2\2\u0256\u0257\7;\2\2\u0257\u025b\7A\2\2\u0258\u025a"+ 15895 "\t\2\2\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b"+ 15896 "\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f\79"+ 15897 "\2\2\u025f)\3\2\2\2\u0260\u0288\5&\24\2\u0261\u0287\5\f\7\2\u0262\u0287"+ 15898 "\5j\66\2\u0263\u0287\5\22\n\2\u0264\u0287\5\30\r\2\u0265\u0287\5\36\20"+ 15899 "\2\u0266\u0287\5$\23\2\u0267\u0287\5\60\31\2\u0268\u0287\5\66\34\2\u0269"+ 15900 "\u0287\5<\37\2\u026a\u0287\5B\"\2\u026b\u0287\5H%\2\u026c\u0287\5N(\2"+ 15901 "\u026d\u0287\5T+\2\u026e\u0287\5Z.\2\u026f\u0287\5f\64\2\u0270\u0287\5"+ 15902 "`\61\2\u0271\u0287\5\16\b\2\u0272\u0287\5\24\13\2\u0273\u0287\5\32\16"+ 15903 "\2\u0274\u0287\5 \21\2\u0275\u0287\5,\27\2\u0276\u0287\5\62\32\2\u0277"+ 15904 "\u0287\58\35\2\u0278\u0287\5> \2\u0279\u0287\5D#\2\u027a\u0287\5J&\2\u027b"+ 15905 "\u0287\5P)\2\u027c\u0287\5V,\2\u027d\u0287\5b\62\2\u027e\u0287\5\\/\2"+ 15906 "\u027f\u0280\6\26\t\2\u0280\u0287\7\3\2\2\u0281\u0287\5\u0094K\2\u0282"+ 15907 "\u0287\7\5\2\2\u0283\u0287\7\b\2\2\u0284\u0287\5\u0096L\2\u0285\u0287"+ 15908 "\5\u0092J\2\u0286\u0261\3\2\2\2\u0286\u0262\3\2\2\2\u0286\u0263\3\2\2"+ 15909 "\2\u0286\u0264\3\2\2\2\u0286\u0265\3\2\2\2\u0286\u0266\3\2\2\2\u0286\u0267"+ 15910 "\3\2\2\2\u0286\u0268\3\2\2\2\u0286\u0269\3\2\2\2\u0286\u026a\3\2\2\2\u0286"+ 15911 "\u026b\3\2\2\2\u0286\u026c\3\2\2\2\u0286\u026d\3\2\2\2\u0286\u026e\3\2"+ 15912 "\2\2\u0286\u026f\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0271\3\2\2\2\u0286"+ 15913 "\u0272\3\2\2\2\u0286\u0273\3\2\2\2\u0286\u0274\3\2\2\2\u0286\u0275\3\2"+ 15914 "\2\2\u0286\u0276\3\2\2\2\u0286\u0277\3\2\2\2\u0286\u0278\3\2\2\2\u0286"+ 15915 "\u0279\3\2\2\2\u0286\u027a\3\2\2\2\u0286\u027b\3\2\2\2\u0286\u027c\3\2"+ 15916 "\2\2\u0286\u027d\3\2\2\2\u0286\u027e\3\2\2\2\u0286\u027f\3\2\2\2\u0286"+ 15917 "\u0281\3\2\2\2\u0286\u0282\3\2\2\2\u0286\u0283\3\2\2\2\u0286\u0284\3\2"+ 15918 "\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+ 15919 "\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\5("+ 15920 "\25\2\u028c+\3\2\2\2\u028d\u028e\7\7\2\2\u028e\u0295\7B\2\2\u028f\u0294"+ 15921 "\5\n\6\2\u0290\u0294\7\b\2\2\u0291\u0294\7\3\2\2\u0292\u0294\7\6\2\2\u0293"+ 15922 "\u028f\3\2\2\2\u0293\u0290\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0292\3\2"+ 15923 "\2\2\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296"+ 15924 "\u0298\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0299\79\2\2\u0299-\3\2\2\2\u029a"+ 15925 "\u029b\7\7\2\2\u029b\u029c\7;\2\2\u029c\u02a0\7B\2\2\u029d\u029f\t\2\2"+ 15926 "\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e\3\2\2\2\u02a0\u02a1"+ 15927 "\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a3\u02a4\79\2\2\u02a4"+ 15928 "/\3\2\2\2\u02a5\u02cd\5,\27\2\u02a6\u02cc\5\f\7\2\u02a7\u02cc\5j\66\2"+ 15929 "\u02a8\u02cc\5\22\n\2\u02a9\u02cc\5\30\r\2\u02aa\u02cc\5\36\20\2\u02ab"+ 15930 "\u02cc\5$\23\2\u02ac\u02cc\5*\26\2\u02ad\u02cc\5\66\34\2\u02ae\u02cc\5"+ 15931 "<\37\2\u02af\u02cc\5B\"\2\u02b0\u02cc\5H%\2\u02b1\u02cc\5N(\2\u02b2\u02cc"+ 15932 "\5T+\2\u02b3\u02cc\5Z.\2\u02b4\u02cc\5f\64\2\u02b5\u02cc\5`\61\2\u02b6"+ 15933 "\u02cc\5\16\b\2\u02b7\u02cc\5\24\13\2\u02b8\u02cc\5\32\16\2\u02b9\u02cc"+ 15934 "\5 \21\2\u02ba\u02cc\5&\24\2\u02bb\u02cc\5\62\32\2\u02bc\u02cc\58\35\2"+ 15935 "\u02bd\u02cc\5> \2\u02be\u02cc\5D#\2\u02bf\u02cc\5J&\2\u02c0\u02cc\5P"+ 15936 ")\2\u02c1\u02cc\5V,\2\u02c2\u02cc\5b\62\2\u02c3\u02cc\5\\/\2\u02c4\u02c5"+ 15937 "\6\31\n\2\u02c5\u02cc\7\3\2\2\u02c6\u02cc\5\u0094K\2\u02c7\u02cc\7\5\2"+ 15938 "\2\u02c8\u02cc\7\b\2\2\u02c9\u02cc\5\u0096L\2\u02ca\u02cc\5\u0092J\2\u02cb"+ 15939 "\u02a6\3\2\2\2\u02cb\u02a7\3\2\2\2\u02cb\u02a8\3\2\2\2\u02cb\u02a9\3\2"+ 15940 "\2\2\u02cb\u02aa\3\2\2\2\u02cb\u02ab\3\2\2\2\u02cb\u02ac\3\2\2\2\u02cb"+ 15941 "\u02ad\3\2\2\2\u02cb\u02ae\3\2\2\2\u02cb\u02af\3\2\2\2\u02cb\u02b0\3\2"+ 15942 "\2\2\u02cb\u02b1\3\2\2\2\u02cb\u02b2\3\2\2\2\u02cb\u02b3\3\2\2\2\u02cb"+ 15943 "\u02b4\3\2\2\2\u02cb\u02b5\3\2\2\2\u02cb\u02b6\3\2\2\2\u02cb\u02b7\3\2"+ 15944 "\2\2\u02cb\u02b8\3\2\2\2\u02cb\u02b9\3\2\2\2\u02cb\u02ba\3\2\2\2\u02cb"+ 15945 "\u02bb\3\2\2\2\u02cb\u02bc\3\2\2\2\u02cb\u02bd\3\2\2\2\u02cb\u02be\3\2"+ 15946 "\2\2\u02cb\u02bf\3\2\2\2\u02cb\u02c0\3\2\2\2\u02cb\u02c1\3\2\2\2\u02cb"+ 15947 "\u02c2\3\2\2\2\u02cb\u02c3\3\2\2\2\u02cb\u02c4\3\2\2\2\u02cb\u02c6\3\2"+ 15948 "\2\2\u02cb\u02c7\3\2\2\2\u02cb\u02c8\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cb"+ 15949 "\u02ca\3\2\2\2\u02cc\u02cf\3\2\2\2\u02cd\u02cb\3\2\2\2\u02cd\u02ce\3\2"+ 15950 "\2\2\u02ce\u02d0\3\2\2\2\u02cf\u02cd\3\2\2\2\u02d0\u02d1\5.\30\2\u02d1"+ 15951 "\61\3\2\2\2\u02d2\u02d3\7\7\2\2\u02d3\u02da\7C\2\2\u02d4\u02d9\5\n\6\2"+ 15952 "\u02d5\u02d9\7\b\2\2\u02d6\u02d9\7\3\2\2\u02d7\u02d9\7\6\2\2\u02d8\u02d4"+ 15953 "\3\2\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d8\u02d7\3\2\2\2\u02d9"+ 15954 "\u02dc\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2"+ 15955 "\2\2\u02dc\u02da\3\2\2\2\u02dd\u02de\79\2\2\u02de\63\3\2\2\2\u02df\u02e0"+ 15956 "\7\7\2\2\u02e0\u02e1\7;\2\2\u02e1\u02e5\7C\2\2\u02e2\u02e4\t\2\2\2\u02e3"+ 15957 "\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2"+ 15958 "\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\79\2\2\u02e9"+ 15959 "\65\3\2\2\2\u02ea\u0312\5\62\32\2\u02eb\u0311\5\f\7\2\u02ec\u0311\5j\66"+ 15960 "\2\u02ed\u0311\5\22\n\2\u02ee\u0311\5\30\r\2\u02ef\u0311\5\36\20\2\u02f0"+ 15961 "\u0311\5$\23\2\u02f1\u0311\5*\26\2\u02f2\u0311\5\60\31\2\u02f3\u0311\5"+ 15962 "<\37\2\u02f4\u0311\5B\"\2\u02f5\u0311\5H%\2\u02f6\u0311\5N(\2\u02f7\u0311"+ 15963 "\5T+\2\u02f8\u0311\5Z.\2\u02f9\u0311\5f\64\2\u02fa\u0311\5`\61\2\u02fb"+ 15964 "\u0311\5\16\b\2\u02fc\u0311\5\24\13\2\u02fd\u0311\5\32\16\2\u02fe\u0311"+ 15965 "\5 \21\2\u02ff\u0311\5&\24\2\u0300\u0311\5,\27\2\u0301\u0311\58\35\2\u0302"+ 15966 "\u0311\5> \2\u0303\u0311\5D#\2\u0304\u0311\5J&\2\u0305\u0311\5P)\2\u0306"+ 15967 "\u0311\5V,\2\u0307\u0311\5b\62\2\u0308\u0311\5\\/\2\u0309\u030a\6\34\13"+ 15968 "\2\u030a\u0311\7\3\2\2\u030b\u0311\5\u0094K\2\u030c\u0311\7\5\2\2\u030d"+ 15969 "\u0311\7\b\2\2\u030e\u0311\5\u0096L\2\u030f\u0311\5\u0092J\2\u0310\u02eb"+ 15970 "\3\2\2\2\u0310\u02ec\3\2\2\2\u0310\u02ed\3\2\2\2\u0310\u02ee\3\2\2\2\u0310"+ 15971 "\u02ef\3\2\2\2\u0310\u02f0\3\2\2\2\u0310\u02f1\3\2\2\2\u0310\u02f2\3\2"+ 15972 "\2\2\u0310\u02f3\3\2\2\2\u0310\u02f4\3\2\2\2\u0310\u02f5\3\2\2\2\u0310"+ 15973 "\u02f6\3\2\2\2\u0310\u02f7\3\2\2\2\u0310\u02f8\3\2\2\2\u0310\u02f9\3\2"+ 15974 "\2\2\u0310\u02fa\3\2\2\2\u0310\u02fb\3\2\2\2\u0310\u02fc\3\2\2\2\u0310"+ 15975 "\u02fd\3\2\2\2\u0310\u02fe\3\2\2\2\u0310\u02ff\3\2\2\2\u0310\u0300\3\2"+ 15976 "\2\2\u0310\u0301\3\2\2\2\u0310\u0302\3\2\2\2\u0310\u0303\3\2\2\2\u0310"+ 15977 "\u0304\3\2\2\2\u0310\u0305\3\2\2\2\u0310\u0306\3\2\2\2\u0310\u0307\3\2"+ 15978 "\2\2\u0310\u0308\3\2\2\2\u0310\u0309\3\2\2\2\u0310\u030b\3\2\2\2\u0310"+ 15979 "\u030c\3\2\2\2\u0310\u030d\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u030f\3\2"+ 15980 "\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+ 15981 "\u0315\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0316\5\64\33\2\u0316\67\3\2"+ 15982 "\2\2\u0317\u0318\7\7\2\2\u0318\u031f\7D\2\2\u0319\u031e\5\n\6\2\u031a"+ 15983 "\u031e\7\b\2\2\u031b\u031e\7\3\2\2\u031c\u031e\7\6\2\2\u031d\u0319\3\2"+ 15984 "\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031c\3\2\2\2\u031e"+ 15985 "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2"+ 15986 "\2\2\u0321\u031f\3\2\2\2\u0322\u0323\79\2\2\u03239\3\2\2\2\u0324\u0325"+ 15987 "\7\7\2\2\u0325\u0326\7;\2\2\u0326\u032a\7D\2\2\u0327\u0329\t\2\2\2\u0328"+ 15988 "\u0327\3\2\2\2\u0329\u032c\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u032b\3\2"+ 15989 "\2\2\u032b\u032d\3\2\2\2\u032c\u032a\3\2\2\2\u032d\u032e\79\2\2\u032e"+ 15990 ";\3\2\2\2\u032f\u0357\58\35\2\u0330\u0356\5\f\7\2\u0331\u0356\5j\66\2"+ 15991 "\u0332\u0356\5\22\n\2\u0333\u0356\5\30\r\2\u0334\u0356\5\36\20\2\u0335"+ 15992 "\u0356\5$\23\2\u0336\u0356\5*\26\2\u0337\u0356\5\60\31\2\u0338\u0356\5"+ 15993 "\66\34\2\u0339\u0356\5B\"\2\u033a\u0356\5H%\2\u033b\u0356\5N(\2\u033c"+ 15994 "\u0356\5T+\2\u033d\u0356\5Z.\2\u033e\u0356\5f\64\2\u033f\u0356\5`\61\2"+ 15995 "\u0340\u0356\5\16\b\2\u0341\u0356\5\24\13\2\u0342\u0356\5\32\16\2\u0343"+ 15996 "\u0356\5 \21\2\u0344\u0356\5&\24\2\u0345\u0356\5,\27\2\u0346\u0356\5\62"+ 15997 "\32\2\u0347\u0356\5> \2\u0348\u0356\5D#\2\u0349\u0356\5J&\2\u034a\u0356"+ 15998 "\5P)\2\u034b\u0356\5V,\2\u034c\u0356\5b\62\2\u034d\u0356\5\\/\2\u034e"+ 15999 "\u034f\6\37\f\2\u034f\u0356\7\3\2\2\u0350\u0356\5\u0094K\2\u0351\u0356"+ 16000 "\7\5\2\2\u0352\u0356\7\b\2\2\u0353\u0356\5\u0096L\2\u0354\u0356\5\u0092"+ 16001 "J\2\u0355\u0330\3\2\2\2\u0355\u0331\3\2\2\2\u0355\u0332\3\2\2\2\u0355"+ 16002 "\u0333\3\2\2\2\u0355\u0334\3\2\2\2\u0355\u0335\3\2\2\2\u0355\u0336\3\2"+ 16003 "\2\2\u0355\u0337\3\2\2\2\u0355\u0338\3\2\2\2\u0355\u0339\3\2\2\2\u0355"+ 16004 "\u033a\3\2\2\2\u0355\u033b\3\2\2\2\u0355\u033c\3\2\2\2\u0355\u033d\3\2"+ 16005 "\2\2\u0355\u033e\3\2\2\2\u0355\u033f\3\2\2\2\u0355\u0340\3\2\2\2\u0355"+ 16006 "\u0341\3\2\2\2\u0355\u0342\3\2\2\2\u0355\u0343\3\2\2\2\u0355\u0344\3\2"+ 16007 "\2\2\u0355\u0345\3\2\2\2\u0355\u0346\3\2\2\2\u0355\u0347\3\2\2\2\u0355"+ 16008 "\u0348\3\2\2\2\u0355\u0349\3\2\2\2\u0355\u034a\3\2\2\2\u0355\u034b\3\2"+ 16009 "\2\2\u0355\u034c\3\2\2\2\u0355\u034d\3\2\2\2\u0355\u034e\3\2\2\2\u0355"+ 16010 "\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0355\u0352\3\2\2\2\u0355\u0353\3\2"+ 16011 "\2\2\u0355\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357"+ 16012 "\u0358\3\2\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\5:"+ 16013 "\36\2\u035b=\3\2\2\2\u035c\u035d\7\7\2\2\u035d\u0364\7E\2\2\u035e\u0363"+ 16014 "\5\n\6\2\u035f\u0363\7\b\2\2\u0360\u0363\7\3\2\2\u0361\u0363\7\6\2\2\u0362"+ 16015 "\u035e\3\2\2\2\u0362\u035f\3\2\2\2\u0362\u0360\3\2\2\2\u0362\u0361\3\2"+ 16016 "\2\2\u0363\u0366\3\2\2\2\u0364\u0362\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+ 16017 "\u0367\3\2\2\2\u0366\u0364\3\2\2\2\u0367\u0368\79\2\2\u0368?\3\2\2\2\u0369"+ 16018 "\u036a\7\7\2\2\u036a\u036b\7;\2\2\u036b\u036f\7E\2\2\u036c\u036e\t\2\2"+ 16019 "\2\u036d\u036c\3\2\2\2\u036e\u0371\3\2\2\2\u036f\u036d\3\2\2\2\u036f\u0370"+ 16020 "\3\2\2\2\u0370\u0372\3\2\2\2\u0371\u036f\3\2\2\2\u0372\u0373\79\2\2\u0373"+ 16021 "A\3\2\2\2\u0374\u039c\5> \2\u0375\u039b\5\f\7\2\u0376\u039b\5j\66\2\u0377"+ 16022 "\u039b\5\22\n\2\u0378\u039b\5\30\r\2\u0379\u039b\5\36\20\2\u037a\u039b"+ 16023 "\5$\23\2\u037b\u039b\5*\26\2\u037c\u039b\5\60\31\2\u037d\u039b\5\66\34"+ 16024 "\2\u037e\u039b\5<\37\2\u037f\u039b\5H%\2\u0380\u039b\5N(\2\u0381\u039b"+ 16025 "\5T+\2\u0382\u039b\5Z.\2\u0383\u039b\5f\64\2\u0384\u039b\5`\61\2\u0385"+ 16026 "\u039b\5\16\b\2\u0386\u039b\5\24\13\2\u0387\u039b\5\32\16\2\u0388\u039b"+ 16027 "\5 \21\2\u0389\u039b\5&\24\2\u038a\u039b\5,\27\2\u038b\u039b\5\62\32\2"+ 16028 "\u038c\u039b\58\35\2\u038d\u039b\5D#\2\u038e\u039b\5J&\2\u038f\u039b\5"+ 16029 "P)\2\u0390\u039b\5V,\2\u0391\u039b\5b\62\2\u0392\u039b\5\\/\2\u0393\u0394"+ 16030 "\6\"\r\2\u0394\u039b\7\3\2\2\u0395\u039b\5\u0094K\2\u0396\u039b\7\5\2"+ 16031 "\2\u0397\u039b\7\b\2\2\u0398\u039b\5\u0096L\2\u0399\u039b\5\u0092J\2\u039a"+ 16032 "\u0375\3\2\2\2\u039a\u0376\3\2\2\2\u039a\u0377\3\2\2\2\u039a\u0378\3\2"+ 16033 "\2\2\u039a\u0379\3\2\2\2\u039a\u037a\3\2\2\2\u039a\u037b\3\2\2\2\u039a"+ 16034 "\u037c\3\2\2\2\u039a\u037d\3\2\2\2\u039a\u037e\3\2\2\2\u039a\u037f\3\2"+ 16035 "\2\2\u039a\u0380\3\2\2\2\u039a\u0381\3\2\2\2\u039a\u0382\3\2\2\2\u039a"+ 16036 "\u0383\3\2\2\2\u039a\u0384\3\2\2\2\u039a\u0385\3\2\2\2\u039a\u0386\3\2"+ 16037 "\2\2\u039a\u0387\3\2\2\2\u039a\u0388\3\2\2\2\u039a\u0389\3\2\2\2\u039a"+ 16038 "\u038a\3\2\2\2\u039a\u038b\3\2\2\2\u039a\u038c\3\2\2\2\u039a\u038d\3\2"+ 16039 "\2\2\u039a\u038e\3\2\2\2\u039a\u038f\3\2\2\2\u039a\u0390\3\2\2\2\u039a"+ 16040 "\u0391\3\2\2\2\u039a\u0392\3\2\2\2\u039a\u0393\3\2\2\2\u039a\u0395\3\2"+ 16041 "\2\2\u039a\u0396\3\2\2\2\u039a\u0397\3\2\2\2\u039a\u0398\3\2\2\2\u039a"+ 16042 "\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2"+ 16043 "\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a0\5@!\2\u03a0C"+ 16044 "\3\2\2\2\u03a1\u03a2\7\7\2\2\u03a2\u03a9\7F\2\2\u03a3\u03a8\5\n\6\2\u03a4"+ 16045 "\u03a8\7\b\2\2\u03a5\u03a8\7\3\2\2\u03a6\u03a8\7\6\2\2\u03a7\u03a3\3\2"+ 16046 "\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6\3\2\2\2\u03a8"+ 16047 "\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ac\3\2"+ 16048 "\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ad\79\2\2\u03adE\3\2\2\2\u03ae\u03af"+ 16049 "\7\7\2\2\u03af\u03b0\7;\2\2\u03b0\u03b4\7F\2\2\u03b1\u03b3\t\2\2\2\u03b2"+ 16050 "\u03b1\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2"+ 16051 "\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b8\79\2\2\u03b8"+ 16052 "G\3\2\2\2\u03b9\u03e1\5D#\2\u03ba\u03e0\5\f\7\2\u03bb\u03e0\5j\66\2\u03bc"+ 16053 "\u03e0\5\22\n\2\u03bd\u03e0\5\30\r\2\u03be\u03e0\5\36\20\2\u03bf\u03e0"+ 16054 "\5$\23\2\u03c0\u03e0\5*\26\2\u03c1\u03e0\5\60\31\2\u03c2\u03e0\5\66\34"+ 16055 "\2\u03c3\u03e0\5<\37\2\u03c4\u03e0\5B\"\2\u03c5\u03e0\5N(\2\u03c6\u03e0"+ 16056 "\5T+\2\u03c7\u03e0\5Z.\2\u03c8\u03e0\5f\64\2\u03c9\u03e0\5`\61\2\u03ca"+ 16057 "\u03e0\5\16\b\2\u03cb\u03e0\5\24\13\2\u03cc\u03e0\5\32\16\2\u03cd\u03e0"+ 16058 "\5 \21\2\u03ce\u03e0\5&\24\2\u03cf\u03e0\5,\27\2\u03d0\u03e0\5\62\32\2"+ 16059 "\u03d1\u03e0\58\35\2\u03d2\u03e0\5> \2\u03d3\u03e0\5J&\2\u03d4\u03e0\5"+ 16060 "P)\2\u03d5\u03e0\5V,\2\u03d6\u03e0\5b\62\2\u03d7\u03e0\5\\/\2\u03d8\u03d9"+ 16061 "\6%\16\2\u03d9\u03e0\7\3\2\2\u03da\u03e0\5\u0094K\2\u03db\u03e0\7\5\2"+ 16062 "\2\u03dc\u03e0\7\b\2\2\u03dd\u03e0\5\u0096L\2\u03de\u03e0\5\u0092J\2\u03df"+ 16063 "\u03ba\3\2\2\2\u03df\u03bb\3\2\2\2\u03df\u03bc\3\2\2\2\u03df\u03bd\3\2"+ 16064 "\2\2\u03df\u03be\3\2\2\2\u03df\u03bf\3\2\2\2\u03df\u03c0\3\2\2\2\u03df"+ 16065 "\u03c1\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03c3\3\2\2\2\u03df\u03c4\3\2"+ 16066 "\2\2\u03df\u03c5\3\2\2\2\u03df\u03c6\3\2\2\2\u03df\u03c7\3\2\2\2\u03df"+ 16067 "\u03c8\3\2\2\2\u03df\u03c9\3\2\2\2\u03df\u03ca\3\2\2\2\u03df\u03cb\3\2"+ 16068 "\2\2\u03df\u03cc\3\2\2\2\u03df\u03cd\3\2\2\2\u03df\u03ce\3\2\2\2\u03df"+ 16069 "\u03cf\3\2\2\2\u03df\u03d0\3\2\2\2\u03df\u03d1\3\2\2\2\u03df\u03d2\3\2"+ 16070 "\2\2\u03df\u03d3\3\2\2\2\u03df\u03d4\3\2\2\2\u03df\u03d5\3\2\2\2\u03df"+ 16071 "\u03d6\3\2\2\2\u03df\u03d7\3\2\2\2\u03df\u03d8\3\2\2\2\u03df\u03da\3\2"+ 16072 "\2\2\u03df\u03db\3\2\2\2\u03df\u03dc\3\2\2\2\u03df\u03dd\3\2\2\2\u03df"+ 16073 "\u03de\3\2\2\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2"+ 16074 "\2\2\u03e2\u03e4\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5F$\2\u03e5I"+ 16075 "\3\2\2\2\u03e6\u03e7\7\7\2\2\u03e7\u03ee\7G\2\2\u03e8\u03ed\5\n\6\2\u03e9"+ 16076 "\u03ed\7\b\2\2\u03ea\u03ed\7\3\2\2\u03eb\u03ed\7\6\2\2\u03ec\u03e8\3\2"+ 16077 "\2\2\u03ec\u03e9\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed"+ 16078 "\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f1\3\2"+ 16079 "\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03f2\79\2\2\u03f2K\3\2\2\2\u03f3\u03f4"+ 16080 "\7\7\2\2\u03f4\u03f5\7;\2\2\u03f5\u03f9\7G\2\2\u03f6\u03f8\t\2\2\2\u03f7"+ 16081 "\u03f6\3\2\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2"+ 16082 "\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03fd\79\2\2\u03fd"+ 16083 "M\3\2\2\2\u03fe\u0426\5J&\2\u03ff\u0425\5\f\7\2\u0400\u0425\5j\66\2\u0401"+ 16084 "\u0425\5\22\n\2\u0402\u0425\5\30\r\2\u0403\u0425\5\36\20\2\u0404\u0425"+ 16085 "\5$\23\2\u0405\u0425\5*\26\2\u0406\u0425\5\60\31\2\u0407\u0425\5\66\34"+ 16086 "\2\u0408\u0425\5<\37\2\u0409\u0425\5B\"\2\u040a\u0425\5H%\2\u040b\u0425"+ 16087 "\5T+\2\u040c\u0425\5Z.\2\u040d\u0425\5f\64\2\u040e\u0425\5`\61\2\u040f"+ 16088 "\u0425\5\16\b\2\u0410\u0425\5\24\13\2\u0411\u0425\5\32\16\2\u0412\u0425"+ 16089 "\5 \21\2\u0413\u0425\5&\24\2\u0414\u0425\5,\27\2\u0415\u0425\5\62\32\2"+ 16090 "\u0416\u0425\58\35\2\u0417\u0425\5> \2\u0418\u0425\5D#\2\u0419\u0425\5"+ 16091 "P)\2\u041a\u0425\5V,\2\u041b\u0425\5b\62\2\u041c\u0425\5\\/\2\u041d\u041e"+ 16092 "\6(\17\2\u041e\u0425\7\3\2\2\u041f\u0425\5\u0094K\2\u0420\u0425\7\5\2"+ 16093 "\2\u0421\u0425\7\b\2\2\u0422\u0425\5\u0096L\2\u0423\u0425\5\u0092J\2\u0424"+ 16094 "\u03ff\3\2\2\2\u0424\u0400\3\2\2\2\u0424\u0401\3\2\2\2\u0424\u0402\3\2"+ 16095 "\2\2\u0424\u0403\3\2\2\2\u0424\u0404\3\2\2\2\u0424\u0405\3\2\2\2\u0424"+ 16096 "\u0406\3\2\2\2\u0424\u0407\3\2\2\2\u0424\u0408\3\2\2\2\u0424\u0409\3\2"+ 16097 "\2\2\u0424\u040a\3\2\2\2\u0424\u040b\3\2\2\2\u0424\u040c\3\2\2\2\u0424"+ 16098 "\u040d\3\2\2\2\u0424\u040e\3\2\2\2\u0424\u040f\3\2\2\2\u0424\u0410\3\2"+ 16099 "\2\2\u0424\u0411\3\2\2\2\u0424\u0412\3\2\2\2\u0424\u0413\3\2\2\2\u0424"+ 16100 "\u0414\3\2\2\2\u0424\u0415\3\2\2\2\u0424\u0416\3\2\2\2\u0424\u0417\3\2"+ 16101 "\2\2\u0424\u0418\3\2\2\2\u0424\u0419\3\2\2\2\u0424\u041a\3\2\2\2\u0424"+ 16102 "\u041b\3\2\2\2\u0424\u041c\3\2\2\2\u0424\u041d\3\2\2\2\u0424\u041f\3\2"+ 16103 "\2\2\u0424\u0420\3\2\2\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424"+ 16104 "\u0423\3\2\2\2\u0425\u0428\3\2\2\2\u0426\u0424\3\2\2\2\u0426\u0427\3\2"+ 16105 "\2\2\u0427\u0429\3\2\2\2\u0428\u0426\3\2\2\2\u0429\u042a\5L\'\2\u042a"+ 16106 "O\3\2\2\2\u042b\u042c\7\7\2\2\u042c\u0433\7H\2\2\u042d\u0432\5\n\6\2\u042e"+ 16107 "\u0432\7\b\2\2\u042f\u0432\7\3\2\2\u0430\u0432\7\6\2\2\u0431\u042d\3\2"+ 16108 "\2\2\u0431\u042e\3\2\2\2\u0431\u042f\3\2\2\2\u0431\u0430\3\2\2\2\u0432"+ 16109 "\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0436\3\2"+ 16110 "\2\2\u0435\u0433\3\2\2\2\u0436\u0437\79\2\2\u0437Q\3\2\2\2\u0438\u0439"+ 16111 "\7\7\2\2\u0439\u043a\7;\2\2\u043a\u043e\7H\2\2\u043b\u043d\t\2\2\2\u043c"+ 16112 "\u043b\3\2\2\2\u043d\u0440\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2"+ 16113 "\2\2\u043f\u0441\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0442\79\2\2\u0442"+ 16114 "S\3\2\2\2\u0443\u046b\5P)\2\u0444\u046a\5\f\7\2\u0445\u046a\5j\66\2\u0446"+ 16115 "\u046a\5\22\n\2\u0447\u046a\5\30\r\2\u0448\u046a\5\36\20\2\u0449\u046a"+ 16116 "\5$\23\2\u044a\u046a\5*\26\2\u044b\u046a\5\60\31\2\u044c\u046a\5\66\34"+ 16117 "\2\u044d\u046a\5<\37\2\u044e\u046a\5B\"\2\u044f\u046a\5H%\2\u0450\u046a"+ 16118 "\5N(\2\u0451\u046a\5Z.\2\u0452\u046a\5f\64\2\u0453\u046a\5`\61\2\u0454"+ 16119 "\u046a\5\16\b\2\u0455\u046a\5\24\13\2\u0456\u046a\5\32\16\2\u0457\u046a"+ 16120 "\5 \21\2\u0458\u046a\5&\24\2\u0459\u046a\5,\27\2\u045a\u046a\5\62\32\2"+ 16121 "\u045b\u046a\58\35\2\u045c\u046a\5> \2\u045d\u046a\5D#\2\u045e\u046a\5"+ 16122 "J&\2\u045f\u046a\5V,\2\u0460\u046a\5b\62\2\u0461\u046a\5\\/\2\u0462\u0463"+ 16123 "\6+\20\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094K\2\u0465\u046a\7\5\2"+ 16124 "\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468\u046a\5\u0092J\2\u0469"+ 16125 "\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469\u0447\3\2"+ 16126 "\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2\2\2\u0469"+ 16127 "\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469\u044e\3\2"+ 16128 "\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2\2\2\u0469"+ 16129 "\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469\u0455\3\2"+ 16130 "\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2\2\2\u0469"+ 16131 "\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469\u045c\3\2"+ 16132 "\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2\2\2\u0469"+ 16133 "\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469\u0464\3\2"+ 16134 "\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2\2\2\u0469"+ 16135 "\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2"+ 16136 "\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5R*\2\u046fU"+ 16137 "\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7I\2\2\u0472\u0477\5\n\6\2\u0473"+ 16138 "\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476\u0472\3\2"+ 16139 "\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477"+ 16140 "\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u047b\3\2"+ 16141 "\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cW\3\2\2\2\u047d\u047e"+ 16142 "\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7I\2\2\u0480\u0482\t\2\2\2\u0481"+ 16143 "\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484\3\2"+ 16144 "\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+ 16145 "Y\3\2\2\2\u0488\u04b0\5V,\2\u0489\u04af\5\f\7\2\u048a\u04af\5j\66\2\u048b"+ 16146 "\u04af\5\22\n\2\u048c\u04af\5\30\r\2\u048d\u04af\5\36\20\2\u048e\u04af"+ 16147 "\5$\23\2\u048f\u04af\5*\26\2\u0490\u04af\5\60\31\2\u0491\u04af\5\66\34"+ 16148 "\2\u0492\u04af\5<\37\2\u0493\u04af\5B\"\2\u0494\u04af\5H%\2\u0495\u04af"+ 16149 "\5N(\2\u0496\u04af\5T+\2\u0497\u04af\5f\64\2\u0498\u04af\5`\61\2\u0499"+ 16150 "\u04af\5\16\b\2\u049a\u04af\5\24\13\2\u049b\u04af\5\32\16\2\u049c\u04af"+ 16151 "\5 \21\2\u049d\u04af\5&\24\2\u049e\u04af\5,\27\2\u049f\u04af\5\62\32\2"+ 16152 "\u04a0\u04af\58\35\2\u04a1\u04af\5> \2\u04a2\u04af\5D#\2\u04a3\u04af\5"+ 16153 "J&\2\u04a4\u04af\5P)\2\u04a5\u04af\5b\62\2\u04a6\u04af\5\\/\2\u04a7\u04a8"+ 16154 "\6.\21\2\u04a8\u04af\7\3\2\2\u04a9\u04af\5\u0094K\2\u04aa\u04af\7\5\2"+ 16155 "\2\u04ab\u04af\7\b\2\2\u04ac\u04af\5\u0096L\2\u04ad\u04af\5\u0092J\2\u04ae"+ 16156 "\u0489\3\2\2\2\u04ae\u048a\3\2\2\2\u04ae\u048b\3\2\2\2\u04ae\u048c\3\2"+ 16157 "\2\2\u04ae\u048d\3\2\2\2\u04ae\u048e\3\2\2\2\u04ae\u048f\3\2\2\2\u04ae"+ 16158 "\u0490\3\2\2\2\u04ae\u0491\3\2\2\2\u04ae\u0492\3\2\2\2\u04ae\u0493\3\2"+ 16159 "\2\2\u04ae\u0494\3\2\2\2\u04ae\u0495\3\2\2\2\u04ae\u0496\3\2\2\2\u04ae"+ 16160 "\u0497\3\2\2\2\u04ae\u0498\3\2\2\2\u04ae\u0499\3\2\2\2\u04ae\u049a\3\2"+ 16161 "\2\2\u04ae\u049b\3\2\2\2\u04ae\u049c\3\2\2\2\u04ae\u049d\3\2\2\2\u04ae"+ 16162 "\u049e\3\2\2\2\u04ae\u049f\3\2\2\2\u04ae\u04a0\3\2\2\2\u04ae\u04a1\3\2"+ 16163 "\2\2\u04ae\u04a2\3\2\2\2\u04ae\u04a3\3\2\2\2\u04ae\u04a4\3\2\2\2\u04ae"+ 16164 "\u04a5\3\2\2\2\u04ae\u04a6\3\2\2\2\u04ae\u04a7\3\2\2\2\u04ae\u04a9\3\2"+ 16165 "\2\2\u04ae\u04aa\3\2\2\2\u04ae\u04ab\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae"+ 16166 "\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b0\u04b1\3\2"+ 16167 "\2\2\u04b1\u04b3\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04b4\5X-\2\u04b4["+ 16168 "\3\2\2\2\u04b5\u04b6\7\7\2\2\u04b6\u04bd\7J\2\2\u04b7\u04bc\5\n\6\2\u04b8"+ 16169 "\u04bc\7\b\2\2\u04b9\u04bc\7\3\2\2\u04ba\u04bc\7\6\2\2\u04bb\u04b7\3\2"+ 16170 "\2\2\u04bb\u04b8\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bb\u04ba\3\2\2\2\u04bc"+ 16171 "\u04bf\3\2\2\2\u04bd\u04bb\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04c0\3\2"+ 16172 "\2\2\u04bf\u04bd\3\2\2\2\u04c0\u04c1\79\2\2\u04c1]\3\2\2\2\u04c2\u04c3"+ 16173 "\7\7\2\2\u04c3\u04c4\7;\2\2\u04c4\u04c8\7J\2\2\u04c5\u04c7\t\2\2\2\u04c6"+ 16174 "\u04c5\3\2\2\2\u04c7\u04ca\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c8\u04c9\3\2"+ 16175 "\2\2\u04c9\u04cb\3\2\2\2\u04ca\u04c8\3\2\2\2\u04cb\u04cc\79\2\2\u04cc"+ 16176 "_\3\2\2\2\u04cd\u04f5\5\\/\2\u04ce\u04f4\5\f\7\2\u04cf\u04f4\5j\66\2\u04d0"+ 16177 "\u04f4\5\22\n\2\u04d1\u04f4\5\30\r\2\u04d2\u04f4\5\36\20\2\u04d3\u04f4"+ 16178 "\5$\23\2\u04d4\u04f4\5*\26\2\u04d5\u04f4\5\60\31\2\u04d6\u04f4\5\66\34"+ 16179 "\2\u04d7\u04f4\5<\37\2\u04d8\u04f4\5B\"\2\u04d9\u04f4\5H%\2\u04da\u04f4"+ 16180 "\5N(\2\u04db\u04f4\5T+\2\u04dc\u04f4\5Z.\2\u04dd\u04f4\5f\64\2\u04de\u04f4"+ 16181 "\5\16\b\2\u04df\u04f4\5\24\13\2\u04e0\u04f4\5\32\16\2\u04e1\u04f4\5 \21"+ 16182 "\2\u04e2\u04f4\5&\24\2\u04e3\u04f4\5,\27\2\u04e4\u04f4\5\62\32\2\u04e5"+ 16183 "\u04f4\58\35\2\u04e6\u04f4\5> \2\u04e7\u04f4\5D#\2\u04e8\u04f4\5J&\2\u04e9"+ 16184 "\u04f4\5P)\2\u04ea\u04f4\5V,\2\u04eb\u04f4\5b\62\2\u04ec\u04ed\6\61\22"+ 16185 "\2\u04ed\u04f4\7\3\2\2\u04ee\u04f4\5\u0094K\2\u04ef\u04f4\7\5\2\2\u04f0"+ 16186 "\u04f4\7\b\2\2\u04f1\u04f4\5\u0096L\2\u04f2\u04f4\5\u0092J\2\u04f3\u04ce"+ 16187 "\3\2\2\2\u04f3\u04cf\3\2\2\2\u04f3\u04d0\3\2\2\2\u04f3\u04d1\3\2\2\2\u04f3"+ 16188 "\u04d2\3\2\2\2\u04f3\u04d3\3\2\2\2\u04f3\u04d4\3\2\2\2\u04f3\u04d5\3\2"+ 16189 "\2\2\u04f3\u04d6\3\2\2\2\u04f3\u04d7\3\2\2\2\u04f3\u04d8\3\2\2\2\u04f3"+ 16190 "\u04d9\3\2\2\2\u04f3\u04da\3\2\2\2\u04f3\u04db\3\2\2\2\u04f3\u04dc\3\2"+ 16191 "\2\2\u04f3\u04dd\3\2\2\2\u04f3\u04de\3\2\2\2\u04f3\u04df\3\2\2\2\u04f3"+ 16192 "\u04e0\3\2\2\2\u04f3\u04e1\3\2\2\2\u04f3\u04e2\3\2\2\2\u04f3\u04e3\3\2"+ 16193 "\2\2\u04f3\u04e4\3\2\2\2\u04f3\u04e5\3\2\2\2\u04f3\u04e6\3\2\2\2\u04f3"+ 16194 "\u04e7\3\2\2\2\u04f3\u04e8\3\2\2\2\u04f3\u04e9\3\2\2\2\u04f3\u04ea\3\2"+ 16195 "\2\2\u04f3\u04eb\3\2\2\2\u04f3\u04ec\3\2\2\2\u04f3\u04ee\3\2\2\2\u04f3"+ 16196 "\u04ef\3\2\2\2\u04f3\u04f0\3\2\2\2\u04f3\u04f1\3\2\2\2\u04f3\u04f2\3\2"+ 16197 "\2\2\u04f4\u04f7\3\2\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6"+ 16198 "\u04f8\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f8\u04f9\5^\60\2\u04f9a\3\2\2\2"+ 16199 "\u04fa\u04fb\7\7\2\2\u04fb\u0502\7K\2\2\u04fc\u0501\5\n\6\2\u04fd\u0501"+ 16200 "\7\b\2\2\u04fe\u0501\7\3\2\2\u04ff\u0501\7\6\2\2\u0500\u04fc\3\2\2\2\u0500"+ 16201 "\u04fd\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u04ff\3\2\2\2\u0501\u0504\3\2"+ 16202 "\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0505\3\2\2\2\u0504"+ 16203 "\u0502\3\2\2\2\u0505\u0506\79\2\2\u0506c\3\2\2\2\u0507\u0508\7\7\2\2\u0508"+ 16204 "\u0509\7;\2\2\u0509\u050d\7K\2\2\u050a\u050c\t\2\2\2\u050b\u050a\3\2\2"+ 16205 "\2\u050c\u050f\3\2\2\2\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u0510"+ 16206 "\3\2\2\2\u050f\u050d\3\2\2\2\u0510\u0511\79\2\2\u0511e\3\2\2\2\u0512\u053a"+ 16207 "\5b\62\2\u0513\u0539\5\f\7\2\u0514\u0539\5j\66\2\u0515\u0539\5\22\n\2"+ 16208 "\u0516\u0539\5\30\r\2\u0517\u0539\5\36\20\2\u0518\u0539\5$\23\2\u0519"+ 16209 "\u0539\5*\26\2\u051a\u0539\5\60\31\2\u051b\u0539\5\66\34\2\u051c\u0539"+ 16210 "\5<\37\2\u051d\u0539\5B\"\2\u051e\u0539\5H%\2\u051f\u0539\5N(\2\u0520"+ 16211 "\u0539\5T+\2\u0521\u0539\5Z.\2\u0522\u0539\5`\61\2\u0523\u0539\5\16\b"+ 16212 "\2\u0524\u0539\5\24\13\2\u0525\u0539\5\32\16\2\u0526\u0539\5 \21\2\u0527"+ 16213 "\u0539\5&\24\2\u0528\u0539\5,\27\2\u0529\u0539\5\62\32\2\u052a\u0539\5"+ 16214 "8\35\2\u052b\u0539\5> \2\u052c\u0539\5D#\2\u052d\u0539\5J&\2\u052e\u0539"+ 16215 "\5P)\2\u052f\u0539\5V,\2\u0530\u0539\5\\/\2\u0531\u0532\6\64\23\2\u0532"+ 16216 "\u0539\7\3\2\2\u0533\u0539\5\u0094K\2\u0534\u0539\7\5\2\2\u0535\u0539"+ 16217 "\7\b\2\2\u0536\u0539\5\u0096L\2\u0537\u0539\5\u0092J\2\u0538\u0513\3\2"+ 16218 "\2\2\u0538\u0514\3\2\2\2\u0538\u0515\3\2\2\2\u0538\u0516\3\2\2\2\u0538"+ 16219 "\u0517\3\2\2\2\u0538\u0518\3\2\2\2\u0538\u0519\3\2\2\2\u0538\u051a\3\2"+ 16220 "\2\2\u0538\u051b\3\2\2\2\u0538\u051c\3\2\2\2\u0538\u051d\3\2\2\2\u0538"+ 16221 "\u051e\3\2\2\2\u0538\u051f\3\2\2\2\u0538\u0520\3\2\2\2\u0538\u0521\3\2"+ 16222 "\2\2\u0538\u0522\3\2\2\2\u0538\u0523\3\2\2\2\u0538\u0524\3\2\2\2\u0538"+ 16223 "\u0525\3\2\2\2\u0538\u0526\3\2\2\2\u0538\u0527\3\2\2\2\u0538\u0528\3\2"+ 16224 "\2\2\u0538\u0529\3\2\2\2\u0538\u052a\3\2\2\2\u0538\u052b\3\2\2\2\u0538"+ 16225 "\u052c\3\2\2\2\u0538\u052d\3\2\2\2\u0538\u052e\3\2\2\2\u0538\u052f\3\2"+ 16226 "\2\2\u0538\u0530\3\2\2\2\u0538\u0531\3\2\2\2\u0538\u0533\3\2\2\2\u0538"+ 16227 "\u0534\3\2\2\2\u0538\u0535\3\2\2\2\u0538\u0536\3\2\2\2\u0538\u0537\3\2"+ 16228 "\2\2\u0539\u053c\3\2\2\2\u053a\u0538\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+ 16229 "\u053d\3\2\2\2\u053c\u053a\3\2\2\2\u053d\u053e\5d\63\2\u053eg\3\2\2\2"+ 16230 "\u053f\u054f\5j\66\2\u0540\u054f\5l\67\2\u0541\u054f\5n8\2\u0542\u054f"+ 16231 "\5p9\2\u0543\u054f\5r:\2\u0544\u054f\5t;\2\u0545\u054f\5v<\2\u0546\u054f"+ 16232 "\5x=\2\u0547\u054f\5z>\2\u0548\u054f\5|?\2\u0549\u054f\5~@\2\u054a\u054f"+ 16233 "\5\u0080A\2\u054b\u054f\5\u0082B\2\u054c\u054f\5\u0084C\2\u054d\u054f"+ 16234 "\5\u0086D\2\u054e\u053f\3\2\2\2\u054e\u0540\3\2\2\2\u054e\u0541\3\2\2"+ 16235 "\2\u054e\u0542\3\2\2\2\u054e\u0543\3\2\2\2\u054e\u0544\3\2\2\2\u054e\u0545"+ 16236 "\3\2\2\2\u054e\u0546\3\2\2\2\u054e\u0547\3\2\2\2\u054e\u0548\3\2\2\2\u054e"+ 16237 "\u0549\3\2\2\2\u054e\u054a\3\2\2\2\u054e\u054b\3\2\2\2\u054e\u054c\3\2"+ 16238 "\2\2\u054e\u054d\3\2\2\2\u054fi\3\2\2\2\u0550\u0551\7\7\2\2\u0551\u0558"+ 16239 "\t\3\2\2\u0552\u0557\5\n\6\2\u0553\u0557\7\b\2\2\u0554\u0557\7\3\2\2\u0555"+ 16240 "\u0557\7\6\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+ 16241 "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+ 16242 "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7:"+ 16243 "\2\2\u055ck\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7L\2\2\u055f\u0564"+ 16244 "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+ 16245 "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+ 16246 "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+ 16247 "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\t\4\2\2\u0569m\3\2\2\2"+ 16248 "\u056a\u056b\7\7\2\2\u056b\u0572\7M\2\2\u056c\u0571\5\n\6\2\u056d\u0571"+ 16249 "\7\b\2\2\u056e\u0571\7\3\2\2\u056f\u0571\7\6\2\2\u0570\u056c\3\2\2\2\u0570"+ 16250 "\u056d\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2"+ 16251 "\2\2\u0572\u0570\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574"+ 16252 "\u0572\3\2\2\2\u0575\u0576\t\4\2\2\u0576o\3\2\2\2\u0577\u0578\7\7\2\2"+ 16253 "\u0578\u057f\7N\2\2\u0579\u057e\5\n\6\2\u057a\u057e\7\b\2\2\u057b\u057e"+ 16254 "\7\3\2\2\u057c\u057e\7\6\2\2\u057d\u0579\3\2\2\2\u057d\u057a\3\2\2\2\u057d"+ 16255 "\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e\u0581\3\2\2\2\u057f\u057d\3\2"+ 16256 "\2\2\u057f\u0580\3\2\2\2\u0580\u0582\3\2\2\2\u0581\u057f\3\2\2\2\u0582"+ 16257 "\u0583\t\4\2\2\u0583q\3\2\2\2\u0584\u0585\7\7\2\2\u0585\u058c\7O\2\2\u0586"+ 16258 "\u058b\5\n\6\2\u0587\u058b\7\b\2\2\u0588\u058b\7\3\2\2\u0589\u058b\7\6"+ 16259 "\2\2\u058a\u0586\3\2\2\2\u058a\u0587\3\2\2\2\u058a\u0588\3\2\2\2\u058a"+ 16260 "\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2\2\2\u058c\u058d\3\2"+ 16261 "\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f\u0590\t\4\2\2\u0590"+ 16262 "s\3\2\2\2\u0591\u0592\7\7\2\2\u0592\u0599\7P\2\2\u0593\u0598\5\n\6\2\u0594"+ 16263 "\u0598\7\b\2\2\u0595\u0598\7\3\2\2\u0596\u0598\7\6\2\2\u0597\u0593\3\2"+ 16264 "\2\2\u0597\u0594\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0596\3\2\2\2\u0598"+ 16265 "\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c\3\2"+ 16266 "\2\2\u059b\u0599\3\2\2\2\u059c\u059d\t\4\2\2\u059du\3\2\2\2\u059e\u059f"+ 16267 "\7\7\2\2\u059f\u05a6\7Q\2\2\u05a0\u05a5\5\n\6\2\u05a1\u05a5\7\b\2\2\u05a2"+ 16268 "\u05a5\7\3\2\2\u05a3\u05a5\7\6\2\2\u05a4\u05a0\3\2\2\2\u05a4\u05a1\3\2"+ 16269 "\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3\3\2\2\2\u05a5\u05a8\3\2\2\2\u05a6"+ 16270 "\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a9\3\2\2\2\u05a8\u05a6\3\2"+ 16271 "\2\2\u05a9\u05aa\t\4\2\2\u05aaw\3\2\2\2\u05ab\u05ac\7\7\2\2\u05ac\u05b3"+ 16272 "\7R\2\2\u05ad\u05b2\5\n\6\2\u05ae\u05b2\7\b\2\2\u05af\u05b2\7\3\2\2\u05b0"+ 16273 "\u05b2\7\6\2\2\u05b1\u05ad\3\2\2\2\u05b1\u05ae\3\2\2\2\u05b1\u05af\3\2"+ 16274 "\2\2\u05b1\u05b0\3\2\2\2\u05b2\u05b5\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b3"+ 16275 "\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b3\3\2\2\2\u05b6\u05b7\t\4"+ 16276 "\2\2\u05b7y\3\2\2\2\u05b8\u05b9\7\7\2\2\u05b9\u05c0\7S\2\2\u05ba\u05bf"+ 16277 "\5\n\6\2\u05bb\u05bf\7\b\2\2\u05bc\u05bf\7\3\2\2\u05bd\u05bf\7\6\2\2\u05be"+ 16278 "\u05ba\3\2\2\2\u05be\u05bb\3\2\2\2\u05be\u05bc\3\2\2\2\u05be\u05bd\3\2"+ 16279 "\2\2\u05bf\u05c2\3\2\2\2\u05c0\u05be\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1"+ 16280 "\u05c3\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c3\u05c4\t\4\2\2\u05c4{\3\2\2\2"+ 16281 "\u05c5\u05c6\7\7\2\2\u05c6\u05cd\7T\2\2\u05c7\u05cc\5\n\6\2\u05c8\u05cc"+ 16282 "\7\b\2\2\u05c9\u05cc\7\3\2\2\u05ca\u05cc\7\6\2\2\u05cb\u05c7\3\2\2\2\u05cb"+ 16283 "\u05c8\3\2\2\2\u05cb\u05c9\3\2\2\2\u05cb\u05ca\3\2\2\2\u05cc\u05cf\3\2"+ 16284 "\2\2\u05cd\u05cb\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05d0\3\2\2\2\u05cf"+ 16285 "\u05cd\3\2\2\2\u05d0\u05d1\t\4\2\2\u05d1}\3\2\2\2\u05d2\u05d3\7\7\2\2"+ 16286 "\u05d3\u05da\7U\2\2\u05d4\u05d9\5\n\6\2\u05d5\u05d9\7\b\2\2\u05d6\u05d9"+ 16287 "\7\3\2\2\u05d7\u05d9\7\6\2\2\u05d8\u05d4\3\2\2\2\u05d8\u05d5\3\2\2\2\u05d8"+ 16288 "\u05d6\3\2\2\2\u05d8\u05d7\3\2\2\2\u05d9\u05dc\3\2\2\2\u05da\u05d8\3\2"+ 16289 "\2\2\u05da\u05db\3\2\2\2\u05db\u05dd\3\2\2\2\u05dc\u05da\3\2\2\2\u05dd"+ 16290 "\u05de\t\4\2\2\u05de\177\3\2\2\2\u05df\u05e0\7\7\2\2\u05e0\u05e7\7V\2"+ 16291 "\2\u05e1\u05e6\5\n\6\2\u05e2\u05e6\7\b\2\2\u05e3\u05e6\7\3\2\2\u05e4\u05e6"+ 16292 "\7\6\2\2\u05e5\u05e1\3\2\2\2\u05e5\u05e2\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5"+ 16293 "\u05e4\3\2\2\2\u05e6\u05e9\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e7\u05e8\3\2"+ 16294 "\2\2\u05e8\u05ea\3\2\2\2\u05e9\u05e7\3\2\2\2\u05ea\u05eb\t\4\2\2\u05eb"+ 16295 "\u0081\3\2\2\2\u05ec\u05ed\7\7\2\2\u05ed\u05f4\7W\2\2\u05ee\u05f3\5\n"+ 16296 "\6\2\u05ef\u05f3\7\b\2\2\u05f0\u05f3\7\3\2\2\u05f1\u05f3\7\6\2\2\u05f2"+ 16297 "\u05ee\3\2\2\2\u05f2\u05ef\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f1\3\2"+ 16298 "\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5"+ 16299 "\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\t\4\2\2\u05f8\u0083\3\2"+ 16300 "\2\2\u05f9\u05fa\7\7\2\2\u05fa\u0601\7X\2\2\u05fb\u0600\5\n\6\2\u05fc"+ 16301 "\u0600\7\b\2\2\u05fd\u0600\7\3\2\2\u05fe\u0600\7\6\2\2\u05ff\u05fb\3\2"+ 16302 "\2\2\u05ff\u05fc\3\2\2\2\u05ff\u05fd\3\2\2\2\u05ff\u05fe\3\2\2\2\u0600"+ 16303 "\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0604\3\2"+ 16304 "\2\2\u0603\u0601\3\2\2\2\u0604\u0605\t\4\2\2\u0605\u0085\3\2\2\2\u0606"+ 16305 "\u0607\7\7\2\2\u0607\u0608\7;\2\2\u0608\u0609\5\u0088E\2\u0609\u060a\7"+ 16306 "9\2\2\u060a\u060b\bD\1\2\u060b\u0087\3\2\2\2\u060c\u060d\t\5\2\2\u060d"+ 16307 "\u0089\3\2\2\2\u060e\u060f\6F\24\2\u060f\u0617\7\3\2\2\u0610\u0617\5\u0094"+ 16308 "K\2\u0611\u0617\7\5\2\2\u0612\u0617\7\b\2\2\u0613\u0617\5\u0096L\2\u0614"+ 16309 "\u0617\5\u0092J\2\u0615\u0617\5\4\3\2\u0616\u060e\3\2\2\2\u0616\u0610"+ 16310 "\3\2\2\2\u0616\u0611\3\2\2\2\u0616\u0612\3\2\2\2\u0616\u0613\3\2\2\2\u0616"+ 16311 "\u0614\3\2\2\2\u0616\u0615\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u0616\3\2"+ 16312 "\2\2\u0618\u0619\3\2\2\2\u0619\u008b\3\2\2\2\u061a\u061e\7\36\2\2\u061b"+ 16313 "\u061d\t\6\2\2\u061c\u061b\3\2\2\2\u061d\u0620\3\2\2\2\u061e\u061c\3\2"+ 16314 "\2\2\u061e\u061f\3\2\2\2\u061f\u0622\3\2\2\2\u0620\u061e\3\2\2\2\u0621"+ 16315 "\u0623\7 \2\2\u0622\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2"+ 16316 "\2\2\u0624\u0626\7#\2\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626"+ 16317 "\u0628\3\2\2\2\u0627\u0629\5\u008eH\2\u0628\u0627\3\2\2\2\u0628\u0629"+ 16318 "\3\2\2\2\u0629\u0640\3\2\2\2\u062a\u062c\t\6\2\2\u062b\u062a\3\2\2\2\u062c"+ 16319 "\u062d\3\2\2\2\u062d\u062b\3\2\2\2\u062d\u062e\3\2\2\2\u062e\u0630\3\2"+ 16320 "\2\2\u062f\u0631\7 \2\2\u0630\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631"+ 16321 "\u0633\3\2\2\2\u0632\u0634\7#\2\2\u0633\u0632\3\2\2\2\u0633\u0634\3\2"+ 16322 "\2\2\u0634\u0636\3\2\2\2\u0635\u0637\5\u008eH\2\u0636\u0635\3\2\2\2\u0636"+ 16323 "\u0637\3\2\2\2\u0637\u0640\3\2\2\2\u0638\u063a\7 \2\2\u0639\u0638\3\2"+ 16324 "\2\2\u0639\u063a\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063d\7#\2\2\u063c"+ 16325 "\u063e\5\u008eH\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0640"+ 16326 "\3\2\2\2\u063f\u061a\3\2\2\2\u063f\u062b\3\2\2\2\u063f\u0639\3\2\2\2\u0640"+ 16327 "\u008d\3\2\2\2\u0641\u0645\7$\2\2\u0642\u0644\t\7\2\2\u0643\u0642\3\2"+ 16328 "\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646"+ 16329 "\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649\7%\2\2\u0649\u008f\3\2"+ 16330 "\2\2\u064a\u064e\7\t\2\2\u064b\u064d\t\b\2\2\u064c\u064b\3\2\2\2\u064d"+ 16331 "\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f\3\2\2\2\u064f\u0652\3\2"+ 16332 "\2\2\u0650\u064e\3\2\2\2\u0651\u0653\5\u008aF\2\u0652\u0651\3\2\2\2\u0652"+ 16333 "\u0653\3\2\2\2\u0653\u070d\3\2\2\2\u0654\u0658\7\n\2\2\u0655\u0657\t\b"+ 16334 "\2\2\u0656\u0655\3\2\2\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+ 16335 "\u0659\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065b\u065d\5\u008a"+ 16336 "F\2\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u070d\3\2\2\2\u065e"+ 16337 "\u0662\7\13\2\2\u065f\u0661\t\b\2\2\u0660\u065f\3\2\2\2\u0661\u0664\3"+ 16338 "\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0666\3\2\2\2\u0664"+ 16339 "\u0662\3\2\2\2\u0665\u0667\7-\2\2\u0666\u0665\3\2\2\2\u0666\u0667\3\2"+ 16340 "\2\2\u0667\u066b\3\2\2\2\u0668\u066a\t\b\2\2\u0669\u0668\3\2\2\2\u066a"+ 16341 "\u066d\3\2\2\2\u066b\u0669\3\2\2\2\u066b\u066c\3\2\2\2\u066c\u066f\3\2"+ 16342 "\2\2\u066d\u066b\3\2\2\2\u066e\u0670\5\u008aF\2\u066f\u066e\3\2\2\2\u066f"+ 16343 "\u0670\3\2\2\2\u0670\u070d\3\2\2\2\u0671\u0675\7\f\2\2\u0672\u0674\t\b"+ 16344 "\2\2\u0673\u0672\3\2\2\2\u0674\u0677\3\2\2\2\u0675\u0673\3\2\2\2\u0675"+ 16345 "\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0675\3\2\2\2\u0678\u067a\7\33"+ 16346 "\2\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067e\3\2\2\2\u067b"+ 16347 "\u067d\t\b\2\2\u067c\u067b\3\2\2\2\u067d\u0680\3\2\2\2\u067e\u067c\3\2"+ 16348 "\2\2\u067e\u067f\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e\3\2\2\2\u0681"+ 16349 "\u0683\5\u008aF\2\u0682\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u070d"+ 16350 "\3\2\2\2\u0684\u0688\7\r\2\2\u0685\u0687\t\b\2\2\u0686\u0685\3\2\2\2\u0687"+ 16351 "\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068c\3\2"+ 16352 "\2\2\u068a\u0688\3\2\2\2\u068b\u068d\5\u008aF\2\u068c\u068b\3\2\2\2\u068c"+ 16353 "\u068d\3\2\2\2\u068d\u070d\3\2\2\2\u068e\u0692\7\16\2\2\u068f\u0691\t"+ 16354 "\b\2\2\u0690\u068f\3\2\2\2\u0691\u0694\3\2\2\2\u0692\u0690\3\2\2\2\u0692"+ 16355 "\u0693\3\2\2\2\u0693\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695\u0697\5\u008c"+ 16356 "G\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069c\3\2\2\2\u0698"+ 16357 "\u069b\7\35\2\2\u0699\u069b\5\4\3\2\u069a\u0698\3\2\2\2\u069a\u0699\3"+ 16358 "\2\2\2\u069b\u069e\3\2\2\2\u069c\u069a\3\2\2\2\u069c\u069d\3\2\2\2\u069d"+ 16359 "\u06a2\3\2\2\2\u069e\u069c\3\2\2\2\u069f\u06a1\t\b\2\2\u06a0\u069f\3\2"+ 16360 "\2\2\u06a1\u06a4\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3"+ 16361 "\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a5\u06a7\5\u008aF\2\u06a6\u06a5"+ 16362 "\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u070d\3\2\2\2\u06a8\u06ac\7\17\2\2"+ 16363 "\u06a9\u06ab\t\b\2\2\u06aa\u06a9\3\2\2\2\u06ab\u06ae\3\2\2\2\u06ac\u06aa"+ 16364 "\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06b0\3\2\2\2\u06ae\u06ac\3\2\2\2\u06af"+ 16365 "\u06b1\t\t\2\2\u06b0\u06af\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b3\3\2"+ 16366 "\2\2\u06b2\u06b4\5\u008aF\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4"+ 16367 "\u070d\3\2\2\2\u06b5\u06b9\7\21\2\2\u06b6\u06b8\t\b\2\2\u06b7\u06b6\3"+ 16368 "\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba"+ 16369 "\u06bd\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5\u008aF\2\u06bd\u06bc"+ 16370 "\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u070d\3\2\2\2\u06bf\u06c3\7\20\2\2"+ 16371 "\u06c0\u06c2\t\b\2\2\u06c1\u06c0\3\2\2\2\u06c2\u06c5\3\2\2\2\u06c3\u06c1"+ 16372 "\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2\2\2\u06c6"+ 16373 "\u06c8\7)\2\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cc\3\2"+ 16374 "\2\2\u06c9\u06cb\t\b\2\2\u06ca\u06c9\3\2\2\2\u06cb\u06ce\3\2\2\2\u06cc"+ 16375 "\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06d0\3\2\2\2\u06ce\u06cc\3\2"+ 16376 "\2\2\u06cf\u06d1\7+\2\2\u06d0\u06cf\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1"+ 16377 "\u06d5\3\2\2\2\u06d2\u06d4\t\b\2\2\u06d3\u06d2\3\2\2\2\u06d4\u06d7\3\2"+ 16378 "\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d9\3\2\2\2\u06d7"+ 16379 "\u06d5\3\2\2\2\u06d8\u06da\5\u008aF\2\u06d9\u06d8\3\2\2\2\u06d9\u06da"+ 16380 "\3\2\2\2\u06da\u070d\3\2\2\2\u06db\u06df\7\22\2\2\u06dc\u06de\t\b\2\2"+ 16381 "\u06dd\u06dc\3\2\2\2\u06de\u06e1\3\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06e0"+ 16382 "\3\2\2\2\u06e0\u06e3\3\2\2\2\u06e1\u06df\3\2\2\2\u06e2\u06e4\5\u008aF"+ 16383 "\2\u06e3\u06e2\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u070d\3\2\2\2\u06e5\u06e9"+ 16384 "\7\23\2\2\u06e6\u06e8\t\b\2\2\u06e7\u06e6\3\2\2\2\u06e8\u06eb\3\2\2\2"+ 16385 "\u06e9\u06e7\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb\u06e9"+ 16386 "\3\2\2\2\u06ec\u06ee\7-\2\2\u06ed\u06ec\3\2\2\2\u06ed\u06ee\3\2\2\2\u06ee"+ 16387 "\u06f2\3\2\2\2\u06ef\u06f1\t\b\2\2\u06f0\u06ef\3\2\2\2\u06f1\u06f4\3\2"+ 16388 "\2\2\u06f2\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f6\3\2\2\2\u06f4"+ 16389 "\u06f2\3\2\2\2\u06f5\u06f7\5\u008aF\2\u06f6\u06f5\3\2\2\2\u06f6\u06f7"+ 16390 "\3\2\2\2\u06f7\u070d\3\2\2\2\u06f8\u06fc\7\24\2\2\u06f9\u06fb\t\b\2\2"+ 16391 "\u06fa\u06f9\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd"+ 16392 "\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06ff\u0701\5\u008aF"+ 16393 "\2\u0700\u06ff\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u070d\3\2\2\2\u0702\u0706"+ 16394 "\7\27\2\2\u0703\u0705\t\b\2\2\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2"+ 16395 "\u0706\u0704\3\2\2\2\u0706\u0707\3\2\2\2\u0707\u070a\3\2\2\2\u0708\u0706"+ 16396 "\3\2\2\2\u0709\u070b\5\u008aF\2\u070a\u0709\3\2\2\2\u070a\u070b\3\2\2"+ 16397 "\2\u070b\u070d\3\2\2\2\u070c\u064a\3\2\2\2\u070c\u0654\3\2\2\2\u070c\u065e"+ 16398 "\3\2\2\2\u070c\u0671\3\2\2\2\u070c\u0684\3\2\2\2\u070c\u068e\3\2\2\2\u070c"+ 16399 "\u06a8\3\2\2\2\u070c\u06b5\3\2\2\2\u070c\u06bf\3\2\2\2\u070c\u06db\3\2"+ 16400 "\2\2\u070c\u06e5\3\2\2\2\u070c\u06f8\3\2\2\2\u070c\u0702\3\2\2\2\u070d"+ 16401 "\u0091\3\2\2\2\u070e\u075a\7\25\2\2\u070f\u0716\7/\2\2\u0710\u0715\7\6"+ 16402 "\2\2\u0711\u0715\7\b\2\2\u0712\u0715\7\3\2\2\u0713\u0715\5\u0096L\2\u0714"+ 16403 "\u0710\3\2\2\2\u0714\u0711\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0713\3\2"+ 16404 "\2\2\u0715\u0718\3\2\2\2\u0716\u0714\3\2\2\2\u0716\u0717\3\2\2\2\u0717"+ 16405 "\u075b\3\2\2\2\u0718\u0716\3\2\2\2\u0719\u071d\7\60\2\2\u071a\u071c\t"+ 16406 "\2\2\2\u071b\u071a\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2\2\2\u071d"+ 16407 "\u071e\3\2\2\2\u071e\u075b\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0724\7\61"+ 16408 "\2\2\u0721\u0723\t\2\2\2\u0722\u0721\3\2\2\2\u0723\u0726\3\2\2\2\u0724"+ 16409 "\u0722\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u075b\3\2\2\2\u0726\u0724\3\2"+ 16410 "\2\2\u0727\u072b\7\62\2\2\u0728\u072a\t\2\2\2\u0729\u0728\3\2\2\2\u072a"+ 16411 "\u072d\3\2\2\2\u072b\u0729\3\2\2\2\u072b\u072c\3\2\2\2\u072c\u072e\3\2"+ 16412 "\2\2\u072d\u072b\3\2\2\2\u072e\u0730\5\u008cG\2\u072f\u0731\5\u008aF\2"+ 16413 "\u0730\u072f\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u075b\3\2\2\2\u0732\u0736"+ 16414 "\7\63\2\2\u0733\u0735\t\2\2\2\u0734\u0733\3\2\2\2\u0735\u0738\3\2\2\2"+ 16415 "\u0736\u0734\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u0739\3\2\2\2\u0738\u0736"+ 16416 "\3\2\2\2\u0739\u073b\5\u008cG\2\u073a\u073c\5\u008aF\2\u073b\u073a\3\2"+ 16417 "\2\2\u073b\u073c\3\2\2\2\u073c\u075b\3\2\2\2\u073d\u0744\7\64\2\2\u073e"+ 16418 "\u0743\7\6\2\2\u073f\u0743\7\b\2\2\u0740\u0743\7\3\2\2\u0741\u0743\5\u0096"+ 16419 "L\2\u0742\u073e\3\2\2\2\u0742\u073f\3\2\2\2\u0742\u0740\3\2\2\2\u0742"+ 16420 "\u0741\3\2\2\2\u0743\u0746\3\2\2\2\u0744\u0742\3\2\2\2\u0744\u0745\3\2"+ 16421 "\2\2\u0745\u075b\3\2\2\2\u0746\u0744\3\2\2\2\u0747\u074b\7\65\2\2\u0748"+ 16422 "\u074a\t\2\2\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749\3\2"+ 16423 "\2\2\u074b\u074c\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+ 16424 "\u0750\5\u008cG\2\u074f\u074e\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u075b"+ 16425 "\3\2\2\2\u0751\u0753\7\27\2\2\u0752\u0754\t\2\2\2\u0753\u0752\3\2\2\2"+ 16426 "\u0754\u0755\3\2\2\2\u0755\u0753\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0758"+ 16427 "\3\2\2\2\u0757\u0759\5\u008aF\2\u0758\u0757\3\2\2\2\u0758\u0759\3\2\2"+ 16428 "\2\u0759\u075b\3\2\2\2\u075a\u070f\3\2\2\2\u075a\u0719\3\2\2\2\u075a\u0720"+ 16429 "\3\2\2\2\u075a\u0727\3\2\2\2\u075a\u0732\3\2\2\2\u075a\u073d\3\2\2\2\u075a"+ 16430 "\u0747\3\2\2\2\u075a\u0751\3\2\2\2\u075b\u075c\3\2\2\2\u075c\u075d\7\26"+ 16431 "\2\2\u075d\u0093\3\2\2\2\u075e\u0764\7\4\2\2\u075f\u0763\5\u0096L\2\u0760"+ 16432 "\u0763\7\b\2\2\u0761\u0763\7\3\2\2\u0762\u075f\3\2\2\2\u0762\u0760\3\2"+ 16433 "\2\2\u0762\u0761\3\2\2\2\u0763\u0766\3\2\2\2\u0764\u0762\3\2\2\2\u0764"+ 16434 "\u0765\3\2\2\2\u0765\u0767\3\2\2\2\u0766\u0764\3\2\2\2\u0767\u0768\7]"+ 16435 "\2\2\u0768\u0095\3\2\2\2\u0769\u076b\t\n\2\2\u076a\u0769\3\2\2\2\u076b"+ 16436 "\u076c\3\2\2\2\u076c\u076a\3\2\2\2\u076c\u076d\3\2\2\2\u076d\u0097\3\2"+ 16437 "\2\2\u00c5\u00a0\u00a2\u00a6\u00ab\u00b1\u00e5\u00ed\u00ef\u00fa\u0103"+ 16438 "\u010a\u0110\u011b\u011d\u012b\u012d\u0132\u013a\u013c\u0147\u0172\u0174"+ 16439 "\u017f\u0181\u018c\u01b7\u01b9\u01c4\u01c6\u01d1\u01fc\u01fe\u0209\u020b"+ 16440 "\u0216\u0241\u0243\u024e\u0250\u025b\u0286\u0288\u0293\u0295\u02a0\u02cb"+ 16441 "\u02cd\u02d8\u02da\u02e5\u0310\u0312\u031d\u031f\u032a\u0355\u0357\u0362"+ 16442 "\u0364\u036f\u039a\u039c\u03a7\u03a9\u03b4\u03df\u03e1\u03ec\u03ee\u03f9"+ 16443 "\u0424\u0426\u0431\u0433\u043e\u0469\u046b\u0476\u0478\u0483\u04ae\u04b0"+ 16444 "\u04bb\u04bd\u04c8\u04f3\u04f5\u0500\u0502\u050d\u0538\u053a\u054e\u0556"+ 16445 "\u0558\u0563\u0565\u0570\u0572\u057d\u057f\u058a\u058c\u0597\u0599\u05a4"+ 16446 "\u05a6\u05b1\u05b3\u05be\u05c0\u05cb\u05cd\u05d8\u05da\u05e5\u05e7\u05f2"+ 16447 "\u05f4\u05ff\u0601\u0616\u0618\u061e\u0622\u0625\u0628\u062d\u0630\u0633"+ 16448 "\u0636\u0639\u063d\u063f\u0645\u064e\u0652\u0658\u065c\u0662\u0666\u066b"+ 16449 "\u066f\u0675\u0679\u067e\u0682\u0688\u068c\u0692\u0696\u069a\u069c\u06a2"+ 16450 "\u06a6\u06ac\u06b0\u06b3\u06b9\u06bd\u06c3\u06c7\u06cc\u06d0\u06d5\u06d9"+ 16451 "\u06df\u06e3\u06e9\u06ed\u06f2\u06f6\u06fc\u0700\u0706\u070a\u070c\u0714"+ 16452 "\u0716\u071d\u0724\u072b\u0730\u0736\u073b\u0742\u0744\u074b\u074f\u0755"+ 16453 "\u0758\u075a\u0762\u0764\u076c"; 16454 public static final ATN _ATN = 16455 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 16456 static { 16457 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; 16458 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { 16459 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); 16460 } 16461 } 16462}