001// Generated from com/puppycrawl/tools/checkstyle/grammars/javadoc/JavadocParser.g4 by ANTLR 4.5.1 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.1", 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 switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { 278 case 1: 279 { 280 setState(150); 281 htmlElement(); 282 } 283 break; 284 case 2: 285 { 286 { 287 setState(151); 288 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 289 setState(152); 290 match(LEADING_ASTERISK); 291 } 292 } 293 break; 294 case 3: 295 { 296 setState(153); 297 htmlComment(); 298 } 299 break; 300 case 4: 301 { 302 setState(154); 303 match(CDATA); 304 } 305 break; 306 case 5: 307 { 308 setState(155); 309 match(NEWLINE); 310 } 311 break; 312 case 6: 313 { 314 setState(156); 315 text(); 316 } 317 break; 318 case 7: 319 { 320 setState(157); 321 javadocInlineTag(); 322 } 323 break; 324 } 325 } 326 } 327 setState(162); 328 _errHandler.sync(this); 329 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 330 } 331 setState(175); 332 _errHandler.sync(this); 333 _la = _input.LA(1); 334 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)) { 335 { 336 { 337 setState(164); 338 _la = _input.LA(1); 339 if (_la==LEADING_ASTERISK) { 340 { 341 setState(163); 342 match(LEADING_ASTERISK); 343 } 344 } 345 346 setState(169); 347 _errHandler.sync(this); 348 _la = _input.LA(1); 349 while (_la==WS) { 350 { 351 { 352 setState(166); 353 match(WS); 354 } 355 } 356 setState(171); 357 _errHandler.sync(this); 358 _la = _input.LA(1); 359 } 360 setState(172); 361 javadocTag(); 362 } 363 } 364 setState(177); 365 _errHandler.sync(this); 366 _la = _input.LA(1); 367 } 368 setState(178); 369 match(EOF); 370 } 371 } 372 catch (RecognitionException re) { 373 _localctx.exception = re; 374 _errHandler.reportError(this, re); 375 _errHandler.recover(this, re); 376 } 377 finally { 378 exitRule(); 379 } 380 return _localctx; 381 } 382 383 public static class HtmlElementContext extends ParserRuleContext { 384 public HtmlTagContext htmlTag() { 385 return getRuleContext(HtmlTagContext.class,0); 386 } 387 public SingletonElementContext singletonElement() { 388 return getRuleContext(SingletonElementContext.class,0); 389 } 390 public ParagraphContext paragraph() { 391 return getRuleContext(ParagraphContext.class,0); 392 } 393 public LiContext li() { 394 return getRuleContext(LiContext.class,0); 395 } 396 public TrContext tr() { 397 return getRuleContext(TrContext.class,0); 398 } 399 public TdContext td() { 400 return getRuleContext(TdContext.class,0); 401 } 402 public ThContext th() { 403 return getRuleContext(ThContext.class,0); 404 } 405 public BodyContext body() { 406 return getRuleContext(BodyContext.class,0); 407 } 408 public ColgroupContext colgroup() { 409 return getRuleContext(ColgroupContext.class,0); 410 } 411 public DdContext dd() { 412 return getRuleContext(DdContext.class,0); 413 } 414 public DtContext dt() { 415 return getRuleContext(DtContext.class,0); 416 } 417 public HeadContext head() { 418 return getRuleContext(HeadContext.class,0); 419 } 420 public HtmlContext html() { 421 return getRuleContext(HtmlContext.class,0); 422 } 423 public OptionContext option() { 424 return getRuleContext(OptionContext.class,0); 425 } 426 public TbodyContext tbody() { 427 return getRuleContext(TbodyContext.class,0); 428 } 429 public TheadContext thead() { 430 return getRuleContext(TheadContext.class,0); 431 } 432 public TfootContext tfoot() { 433 return getRuleContext(TfootContext.class,0); 434 } 435 public PTagOpenContext pTagOpen() { 436 return getRuleContext(PTagOpenContext.class,0); 437 } 438 public LiTagOpenContext liTagOpen() { 439 return getRuleContext(LiTagOpenContext.class,0); 440 } 441 public TrTagOpenContext trTagOpen() { 442 return getRuleContext(TrTagOpenContext.class,0); 443 } 444 public TdTagOpenContext tdTagOpen() { 445 return getRuleContext(TdTagOpenContext.class,0); 446 } 447 public ThTagOpenContext thTagOpen() { 448 return getRuleContext(ThTagOpenContext.class,0); 449 } 450 public BodyTagOpenContext bodyTagOpen() { 451 return getRuleContext(BodyTagOpenContext.class,0); 452 } 453 public ColgroupTagOpenContext colgroupTagOpen() { 454 return getRuleContext(ColgroupTagOpenContext.class,0); 455 } 456 public DdTagOpenContext ddTagOpen() { 457 return getRuleContext(DdTagOpenContext.class,0); 458 } 459 public DtTagOpenContext dtTagOpen() { 460 return getRuleContext(DtTagOpenContext.class,0); 461 } 462 public HeadTagOpenContext headTagOpen() { 463 return getRuleContext(HeadTagOpenContext.class,0); 464 } 465 public HtmlTagOpenContext htmlTagOpen() { 466 return getRuleContext(HtmlTagOpenContext.class,0); 467 } 468 public OptionTagOpenContext optionTagOpen() { 469 return getRuleContext(OptionTagOpenContext.class,0); 470 } 471 public TbodyTagOpenContext tbodyTagOpen() { 472 return getRuleContext(TbodyTagOpenContext.class,0); 473 } 474 public TheadTagOpenContext theadTagOpen() { 475 return getRuleContext(TheadTagOpenContext.class,0); 476 } 477 public TfootTagOpenContext tfootTagOpen() { 478 return getRuleContext(TfootTagOpenContext.class,0); 479 } 480 public PTagCloseContext pTagClose() { 481 return getRuleContext(PTagCloseContext.class,0); 482 } 483 public LiTagCloseContext liTagClose() { 484 return getRuleContext(LiTagCloseContext.class,0); 485 } 486 public TrTagCloseContext trTagClose() { 487 return getRuleContext(TrTagCloseContext.class,0); 488 } 489 public TdTagCloseContext tdTagClose() { 490 return getRuleContext(TdTagCloseContext.class,0); 491 } 492 public ThTagCloseContext thTagClose() { 493 return getRuleContext(ThTagCloseContext.class,0); 494 } 495 public BodyTagCloseContext bodyTagClose() { 496 return getRuleContext(BodyTagCloseContext.class,0); 497 } 498 public ColgroupTagCloseContext colgroupTagClose() { 499 return getRuleContext(ColgroupTagCloseContext.class,0); 500 } 501 public DdTagCloseContext ddTagClose() { 502 return getRuleContext(DdTagCloseContext.class,0); 503 } 504 public DtTagCloseContext dtTagClose() { 505 return getRuleContext(DtTagCloseContext.class,0); 506 } 507 public HeadTagCloseContext headTagClose() { 508 return getRuleContext(HeadTagCloseContext.class,0); 509 } 510 public HtmlTagCloseContext htmlTagClose() { 511 return getRuleContext(HtmlTagCloseContext.class,0); 512 } 513 public OptionTagCloseContext optionTagClose() { 514 return getRuleContext(OptionTagCloseContext.class,0); 515 } 516 public TbodyTagCloseContext tbodyTagClose() { 517 return getRuleContext(TbodyTagCloseContext.class,0); 518 } 519 public TheadTagCloseContext theadTagClose() { 520 return getRuleContext(TheadTagCloseContext.class,0); 521 } 522 public TfootTagCloseContext tfootTagClose() { 523 return getRuleContext(TfootTagCloseContext.class,0); 524 } 525 public HtmlElementContext(ParserRuleContext parent, int invokingState) { 526 super(parent, invokingState); 527 } 528 @Override public int getRuleIndex() { return RULE_htmlElement; } 529 @Override 530 public void enterRule(ParseTreeListener listener) { 531 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElement(this); 532 } 533 @Override 534 public void exitRule(ParseTreeListener listener) { 535 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElement(this); 536 } 537 @Override 538 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 539 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElement(this); 540 else return visitor.visitChildren(this); 541 } 542 } 543 544 public final HtmlElementContext htmlElement() throws RecognitionException { 545 HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState()); 546 enterRule(_localctx, 2, RULE_htmlElement); 547 try { 548 setState(227); 549 switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { 550 case 1: 551 enterOuterAlt(_localctx, 1); 552 { 553 setState(180); 554 htmlTag(); 555 } 556 break; 557 case 2: 558 enterOuterAlt(_localctx, 2); 559 { 560 setState(181); 561 singletonElement(); 562 } 563 break; 564 case 3: 565 enterOuterAlt(_localctx, 3); 566 { 567 setState(182); 568 paragraph(); 569 } 570 break; 571 case 4: 572 enterOuterAlt(_localctx, 4); 573 { 574 setState(183); 575 li(); 576 } 577 break; 578 case 5: 579 enterOuterAlt(_localctx, 5); 580 { 581 setState(184); 582 tr(); 583 } 584 break; 585 case 6: 586 enterOuterAlt(_localctx, 6); 587 { 588 setState(185); 589 td(); 590 } 591 break; 592 case 7: 593 enterOuterAlt(_localctx, 7); 594 { 595 setState(186); 596 th(); 597 } 598 break; 599 case 8: 600 enterOuterAlt(_localctx, 8); 601 { 602 setState(187); 603 body(); 604 } 605 break; 606 case 9: 607 enterOuterAlt(_localctx, 9); 608 { 609 setState(188); 610 colgroup(); 611 } 612 break; 613 case 10: 614 enterOuterAlt(_localctx, 10); 615 { 616 setState(189); 617 dd(); 618 } 619 break; 620 case 11: 621 enterOuterAlt(_localctx, 11); 622 { 623 setState(190); 624 dt(); 625 } 626 break; 627 case 12: 628 enterOuterAlt(_localctx, 12); 629 { 630 setState(191); 631 head(); 632 } 633 break; 634 case 13: 635 enterOuterAlt(_localctx, 13); 636 { 637 setState(192); 638 html(); 639 } 640 break; 641 case 14: 642 enterOuterAlt(_localctx, 14); 643 { 644 setState(193); 645 option(); 646 } 647 break; 648 case 15: 649 enterOuterAlt(_localctx, 15); 650 { 651 setState(194); 652 tbody(); 653 } 654 break; 655 case 16: 656 enterOuterAlt(_localctx, 16); 657 { 658 setState(195); 659 thead(); 660 } 661 break; 662 case 17: 663 enterOuterAlt(_localctx, 17); 664 { 665 setState(196); 666 tfoot(); 667 } 668 break; 669 case 18: 670 enterOuterAlt(_localctx, 18); 671 { 672 setState(197); 673 pTagOpen(); 674 } 675 break; 676 case 19: 677 enterOuterAlt(_localctx, 19); 678 { 679 setState(198); 680 liTagOpen(); 681 } 682 break; 683 case 20: 684 enterOuterAlt(_localctx, 20); 685 { 686 setState(199); 687 trTagOpen(); 688 } 689 break; 690 case 21: 691 enterOuterAlt(_localctx, 21); 692 { 693 setState(200); 694 tdTagOpen(); 695 } 696 break; 697 case 22: 698 enterOuterAlt(_localctx, 22); 699 { 700 setState(201); 701 thTagOpen(); 702 } 703 break; 704 case 23: 705 enterOuterAlt(_localctx, 23); 706 { 707 setState(202); 708 bodyTagOpen(); 709 } 710 break; 711 case 24: 712 enterOuterAlt(_localctx, 24); 713 { 714 setState(203); 715 colgroupTagOpen(); 716 } 717 break; 718 case 25: 719 enterOuterAlt(_localctx, 25); 720 { 721 setState(204); 722 ddTagOpen(); 723 } 724 break; 725 case 26: 726 enterOuterAlt(_localctx, 26); 727 { 728 setState(205); 729 dtTagOpen(); 730 } 731 break; 732 case 27: 733 enterOuterAlt(_localctx, 27); 734 { 735 setState(206); 736 headTagOpen(); 737 } 738 break; 739 case 28: 740 enterOuterAlt(_localctx, 28); 741 { 742 setState(207); 743 htmlTagOpen(); 744 } 745 break; 746 case 29: 747 enterOuterAlt(_localctx, 29); 748 { 749 setState(208); 750 optionTagOpen(); 751 } 752 break; 753 case 30: 754 enterOuterAlt(_localctx, 30); 755 { 756 setState(209); 757 tbodyTagOpen(); 758 } 759 break; 760 case 31: 761 enterOuterAlt(_localctx, 31); 762 { 763 setState(210); 764 theadTagOpen(); 765 } 766 break; 767 case 32: 768 enterOuterAlt(_localctx, 32); 769 { 770 setState(211); 771 tfootTagOpen(); 772 } 773 break; 774 case 33: 775 enterOuterAlt(_localctx, 33); 776 { 777 setState(212); 778 pTagClose(); 779 } 780 break; 781 case 34: 782 enterOuterAlt(_localctx, 34); 783 { 784 setState(213); 785 liTagClose(); 786 } 787 break; 788 case 35: 789 enterOuterAlt(_localctx, 35); 790 { 791 setState(214); 792 trTagClose(); 793 } 794 break; 795 case 36: 796 enterOuterAlt(_localctx, 36); 797 { 798 setState(215); 799 tdTagClose(); 800 } 801 break; 802 case 37: 803 enterOuterAlt(_localctx, 37); 804 { 805 setState(216); 806 thTagClose(); 807 } 808 break; 809 case 38: 810 enterOuterAlt(_localctx, 38); 811 { 812 setState(217); 813 bodyTagClose(); 814 } 815 break; 816 case 39: 817 enterOuterAlt(_localctx, 39); 818 { 819 setState(218); 820 colgroupTagClose(); 821 } 822 break; 823 case 40: 824 enterOuterAlt(_localctx, 40); 825 { 826 setState(219); 827 ddTagClose(); 828 } 829 break; 830 case 41: 831 enterOuterAlt(_localctx, 41); 832 { 833 setState(220); 834 dtTagClose(); 835 } 836 break; 837 case 42: 838 enterOuterAlt(_localctx, 42); 839 { 840 setState(221); 841 headTagClose(); 842 } 843 break; 844 case 43: 845 enterOuterAlt(_localctx, 43); 846 { 847 setState(222); 848 htmlTagClose(); 849 } 850 break; 851 case 44: 852 enterOuterAlt(_localctx, 44); 853 { 854 setState(223); 855 optionTagClose(); 856 } 857 break; 858 case 45: 859 enterOuterAlt(_localctx, 45); 860 { 861 setState(224); 862 tbodyTagClose(); 863 } 864 break; 865 case 46: 866 enterOuterAlt(_localctx, 46); 867 { 868 setState(225); 869 theadTagClose(); 870 } 871 break; 872 case 47: 873 enterOuterAlt(_localctx, 47); 874 { 875 setState(226); 876 tfootTagClose(); 877 } 878 break; 879 } 880 } 881 catch (RecognitionException re) { 882 _localctx.exception = re; 883 _errHandler.reportError(this, re); 884 _errHandler.recover(this, re); 885 } 886 finally { 887 exitRule(); 888 } 889 return _localctx; 890 } 891 892 public static class HtmlElementOpenContext extends ParserRuleContext { 893 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 894 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 895 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 896 public List<AttributeContext> attribute() { 897 return getRuleContexts(AttributeContext.class); 898 } 899 public AttributeContext attribute(int i) { 900 return getRuleContext(AttributeContext.class,i); 901 } 902 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 903 public TerminalNode NEWLINE(int i) { 904 return getToken(JavadocParser.NEWLINE, i); 905 } 906 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 907 public TerminalNode LEADING_ASTERISK(int i) { 908 return getToken(JavadocParser.LEADING_ASTERISK, i); 909 } 910 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 911 public TerminalNode WS(int i) { 912 return getToken(JavadocParser.WS, i); 913 } 914 public HtmlElementOpenContext(ParserRuleContext parent, int invokingState) { 915 super(parent, invokingState); 916 } 917 @Override public int getRuleIndex() { return RULE_htmlElementOpen; } 918 @Override 919 public void enterRule(ParseTreeListener listener) { 920 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementOpen(this); 921 } 922 @Override 923 public void exitRule(ParseTreeListener listener) { 924 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementOpen(this); 925 } 926 @Override 927 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 928 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementOpen(this); 929 else return visitor.visitChildren(this); 930 } 931 } 932 933 public final HtmlElementOpenContext htmlElementOpen() throws RecognitionException { 934 HtmlElementOpenContext _localctx = new HtmlElementOpenContext(_ctx, getState()); 935 enterRule(_localctx, 4, RULE_htmlElementOpen); 936 int _la; 937 try { 938 enterOuterAlt(_localctx, 1); 939 { 940 setState(229); 941 match(OPEN); 942 setState(230); 943 match(HTML_TAG_NAME); 944 setState(237); 945 _errHandler.sync(this); 946 _la = _input.LA(1); 947 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 948 { 949 setState(235); 950 switch (_input.LA(1)) { 951 case HTML_TAG_NAME: 952 { 953 setState(231); 954 attribute(); 955 } 956 break; 957 case NEWLINE: 958 { 959 setState(232); 960 match(NEWLINE); 961 } 962 break; 963 case LEADING_ASTERISK: 964 { 965 setState(233); 966 match(LEADING_ASTERISK); 967 } 968 break; 969 case WS: 970 { 971 setState(234); 972 match(WS); 973 } 974 break; 975 default: 976 throw new NoViableAltException(this); 977 } 978 } 979 setState(239); 980 _errHandler.sync(this); 981 _la = _input.LA(1); 982 } 983 setState(240); 984 match(CLOSE); 985 } 986 } 987 catch (RecognitionException re) { 988 _localctx.exception = re; 989 _errHandler.reportError(this, re); 990 _errHandler.recover(this, re); 991 } 992 finally { 993 exitRule(); 994 } 995 return _localctx; 996 } 997 998 public static class HtmlElementCloseContext extends ParserRuleContext { 999 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1000 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1001 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 1002 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1003 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1004 public TerminalNode NEWLINE(int i) { 1005 return getToken(JavadocParser.NEWLINE, i); 1006 } 1007 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1008 public TerminalNode LEADING_ASTERISK(int i) { 1009 return getToken(JavadocParser.LEADING_ASTERISK, i); 1010 } 1011 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1012 public TerminalNode WS(int i) { 1013 return getToken(JavadocParser.WS, i); 1014 } 1015 public HtmlElementCloseContext(ParserRuleContext parent, int invokingState) { 1016 super(parent, invokingState); 1017 } 1018 @Override public int getRuleIndex() { return RULE_htmlElementClose; } 1019 @Override 1020 public void enterRule(ParseTreeListener listener) { 1021 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementClose(this); 1022 } 1023 @Override 1024 public void exitRule(ParseTreeListener listener) { 1025 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementClose(this); 1026 } 1027 @Override 1028 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1029 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementClose(this); 1030 else return visitor.visitChildren(this); 1031 } 1032 } 1033 1034 public final HtmlElementCloseContext htmlElementClose() throws RecognitionException { 1035 HtmlElementCloseContext _localctx = new HtmlElementCloseContext(_ctx, getState()); 1036 enterRule(_localctx, 6, RULE_htmlElementClose); 1037 int _la; 1038 try { 1039 enterOuterAlt(_localctx, 1); 1040 { 1041 setState(242); 1042 match(OPEN); 1043 setState(243); 1044 match(SLASH); 1045 setState(244); 1046 match(HTML_TAG_NAME); 1047 setState(248); 1048 _errHandler.sync(this); 1049 _la = _input.LA(1); 1050 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1051 { 1052 { 1053 setState(245); 1054 _la = _input.LA(1); 1055 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1056 _errHandler.recoverInline(this); 1057 } else { 1058 consume(); 1059 } 1060 } 1061 } 1062 setState(250); 1063 _errHandler.sync(this); 1064 _la = _input.LA(1); 1065 } 1066 setState(251); 1067 match(CLOSE); 1068 } 1069 } 1070 catch (RecognitionException re) { 1071 _localctx.exception = re; 1072 _errHandler.reportError(this, re); 1073 _errHandler.recover(this, re); 1074 } 1075 finally { 1076 exitRule(); 1077 } 1078 return _localctx; 1079 } 1080 1081 public static class AttributeContext extends ParserRuleContext { 1082 public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); } 1083 public TerminalNode HTML_TAG_NAME(int i) { 1084 return getToken(JavadocParser.HTML_TAG_NAME, i); 1085 } 1086 public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); } 1087 public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); } 1088 public TextContext text() { 1089 return getRuleContext(TextContext.class,0); 1090 } 1091 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1092 public TerminalNode NEWLINE(int i) { 1093 return getToken(JavadocParser.NEWLINE, i); 1094 } 1095 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1096 public TerminalNode LEADING_ASTERISK(int i) { 1097 return getToken(JavadocParser.LEADING_ASTERISK, i); 1098 } 1099 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1100 public TerminalNode WS(int i) { 1101 return getToken(JavadocParser.WS, i); 1102 } 1103 public AttributeContext(ParserRuleContext parent, int invokingState) { 1104 super(parent, invokingState); 1105 } 1106 @Override public int getRuleIndex() { return RULE_attribute; } 1107 @Override 1108 public void enterRule(ParseTreeListener listener) { 1109 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAttribute(this); 1110 } 1111 @Override 1112 public void exitRule(ParseTreeListener listener) { 1113 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAttribute(this); 1114 } 1115 @Override 1116 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1117 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAttribute(this); 1118 else return visitor.visitChildren(this); 1119 } 1120 } 1121 1122 public final AttributeContext attribute() throws RecognitionException { 1123 AttributeContext _localctx = new AttributeContext(_ctx, getState()); 1124 enterRule(_localctx, 8, RULE_attribute); 1125 int _la; 1126 try { 1127 int _alt; 1128 enterOuterAlt(_localctx, 1); 1129 { 1130 setState(253); 1131 match(HTML_TAG_NAME); 1132 setState(257); 1133 _errHandler.sync(this); 1134 _la = _input.LA(1); 1135 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1136 { 1137 { 1138 setState(254); 1139 _la = _input.LA(1); 1140 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1141 _errHandler.recoverInline(this); 1142 } else { 1143 consume(); 1144 } 1145 } 1146 } 1147 setState(259); 1148 _errHandler.sync(this); 1149 _la = _input.LA(1); 1150 } 1151 setState(260); 1152 match(EQUALS); 1153 setState(264); 1154 _errHandler.sync(this); 1155 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1156 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1157 if ( _alt==1 ) { 1158 { 1159 { 1160 setState(261); 1161 _la = _input.LA(1); 1162 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1163 _errHandler.recoverInline(this); 1164 } else { 1165 consume(); 1166 } 1167 } 1168 } 1169 } 1170 setState(266); 1171 _errHandler.sync(this); 1172 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1173 } 1174 setState(270); 1175 switch (_input.LA(1)) { 1176 case ATTR_VALUE: 1177 { 1178 setState(267); 1179 match(ATTR_VALUE); 1180 } 1181 break; 1182 case WS: 1183 case CHAR: 1184 { 1185 setState(268); 1186 text(); 1187 } 1188 break; 1189 case HTML_TAG_NAME: 1190 { 1191 setState(269); 1192 match(HTML_TAG_NAME); 1193 } 1194 break; 1195 default: 1196 throw new NoViableAltException(this); 1197 } 1198 } 1199 } 1200 catch (RecognitionException re) { 1201 _localctx.exception = re; 1202 _errHandler.reportError(this, re); 1203 _errHandler.recover(this, re); 1204 } 1205 finally { 1206 exitRule(); 1207 } 1208 return _localctx; 1209 } 1210 1211 public static class HtmlTagContext extends ParserRuleContext { 1212 public HtmlElementOpenContext htmlElementOpen; 1213 public HtmlElementOpenContext htmlElementOpen() { 1214 return getRuleContext(HtmlElementOpenContext.class,0); 1215 } 1216 public HtmlElementCloseContext htmlElementClose() { 1217 return getRuleContext(HtmlElementCloseContext.class,0); 1218 } 1219 public List<HtmlElementContext> htmlElement() { 1220 return getRuleContexts(HtmlElementContext.class); 1221 } 1222 public HtmlElementContext htmlElement(int i) { 1223 return getRuleContext(HtmlElementContext.class,i); 1224 } 1225 public List<HtmlCommentContext> htmlComment() { 1226 return getRuleContexts(HtmlCommentContext.class); 1227 } 1228 public HtmlCommentContext htmlComment(int i) { 1229 return getRuleContext(HtmlCommentContext.class,i); 1230 } 1231 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1232 public TerminalNode CDATA(int i) { 1233 return getToken(JavadocParser.CDATA, i); 1234 } 1235 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1236 public TerminalNode NEWLINE(int i) { 1237 return getToken(JavadocParser.NEWLINE, i); 1238 } 1239 public List<TextContext> text() { 1240 return getRuleContexts(TextContext.class); 1241 } 1242 public TextContext text(int i) { 1243 return getRuleContext(TextContext.class,i); 1244 } 1245 public List<JavadocInlineTagContext> javadocInlineTag() { 1246 return getRuleContexts(JavadocInlineTagContext.class); 1247 } 1248 public JavadocInlineTagContext javadocInlineTag(int i) { 1249 return getRuleContext(JavadocInlineTagContext.class,i); 1250 } 1251 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1252 public TerminalNode LEADING_ASTERISK(int i) { 1253 return getToken(JavadocParser.LEADING_ASTERISK, i); 1254 } 1255 public HtmlTagContext(ParserRuleContext parent, int invokingState) { 1256 super(parent, invokingState); 1257 } 1258 @Override public int getRuleIndex() { return RULE_htmlTag; } 1259 @Override 1260 public void enterRule(ParseTreeListener listener) { 1261 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTag(this); 1262 } 1263 @Override 1264 public void exitRule(ParseTreeListener listener) { 1265 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTag(this); 1266 } 1267 @Override 1268 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1269 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTag(this); 1270 else return visitor.visitChildren(this); 1271 } 1272 } 1273 1274 public final HtmlTagContext htmlTag() throws RecognitionException { 1275 HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState()); 1276 enterRule(_localctx, 10, RULE_htmlTag); 1277 try { 1278 int _alt; 1279 setState(304); 1280 switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { 1281 case 1: 1282 enterOuterAlt(_localctx, 1); 1283 { 1284 setState(272); 1285 htmlElementOpen(); 1286 setState(283); 1287 _errHandler.sync(this); 1288 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1289 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1290 if ( _alt==1 ) { 1291 { 1292 setState(281); 1293 switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { 1294 case 1: 1295 { 1296 setState(273); 1297 htmlElement(); 1298 } 1299 break; 1300 case 2: 1301 { 1302 { 1303 setState(274); 1304 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1305 setState(275); 1306 match(LEADING_ASTERISK); 1307 } 1308 } 1309 break; 1310 case 3: 1311 { 1312 setState(276); 1313 htmlComment(); 1314 } 1315 break; 1316 case 4: 1317 { 1318 setState(277); 1319 match(CDATA); 1320 } 1321 break; 1322 case 5: 1323 { 1324 setState(278); 1325 match(NEWLINE); 1326 } 1327 break; 1328 case 6: 1329 { 1330 setState(279); 1331 text(); 1332 } 1333 break; 1334 case 7: 1335 { 1336 setState(280); 1337 javadocInlineTag(); 1338 } 1339 break; 1340 } 1341 } 1342 } 1343 setState(285); 1344 _errHandler.sync(this); 1345 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1346 } 1347 setState(286); 1348 htmlElementClose(); 1349 } 1350 break; 1351 case 2: 1352 enterOuterAlt(_localctx, 2); 1353 { 1354 setState(288); 1355 ((HtmlTagContext)_localctx).htmlElementOpen = htmlElementOpen(); 1356 setState(299); 1357 _errHandler.sync(this); 1358 _alt = getInterpreter().adaptivePredict(_input,15,_ctx); 1359 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1360 if ( _alt==1 ) { 1361 { 1362 setState(297); 1363 switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { 1364 case 1: 1365 { 1366 setState(289); 1367 htmlElement(); 1368 } 1369 break; 1370 case 2: 1371 { 1372 { 1373 setState(290); 1374 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1375 setState(291); 1376 match(LEADING_ASTERISK); 1377 } 1378 } 1379 break; 1380 case 3: 1381 { 1382 setState(292); 1383 htmlComment(); 1384 } 1385 break; 1386 case 4: 1387 { 1388 setState(293); 1389 match(CDATA); 1390 } 1391 break; 1392 case 5: 1393 { 1394 setState(294); 1395 match(NEWLINE); 1396 } 1397 break; 1398 case 6: 1399 { 1400 setState(295); 1401 text(); 1402 } 1403 break; 1404 case 7: 1405 { 1406 setState(296); 1407 javadocInlineTag(); 1408 } 1409 break; 1410 } 1411 } 1412 } 1413 setState(301); 1414 _errHandler.sync(this); 1415 _alt = getInterpreter().adaptivePredict(_input,15,_ctx); 1416 } 1417 notifyErrorListeners(((HtmlTagContext)_localctx).htmlElementOpen.getToken(HTML_TAG_NAME, 0).getSymbol(), "javadoc.missed.html.close", null); 1418 } 1419 break; 1420 } 1421 } 1422 catch (RecognitionException re) { 1423 _localctx.exception = re; 1424 _errHandler.reportError(this, re); 1425 _errHandler.recover(this, re); 1426 } 1427 finally { 1428 exitRule(); 1429 } 1430 return _localctx; 1431 } 1432 1433 public static class PTagOpenContext extends ParserRuleContext { 1434 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1435 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1436 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1437 public List<AttributeContext> attribute() { 1438 return getRuleContexts(AttributeContext.class); 1439 } 1440 public AttributeContext attribute(int i) { 1441 return getRuleContext(AttributeContext.class,i); 1442 } 1443 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1444 public TerminalNode NEWLINE(int i) { 1445 return getToken(JavadocParser.NEWLINE, i); 1446 } 1447 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1448 public TerminalNode LEADING_ASTERISK(int i) { 1449 return getToken(JavadocParser.LEADING_ASTERISK, i); 1450 } 1451 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1452 public TerminalNode WS(int i) { 1453 return getToken(JavadocParser.WS, i); 1454 } 1455 public PTagOpenContext(ParserRuleContext parent, int invokingState) { 1456 super(parent, invokingState); 1457 } 1458 @Override public int getRuleIndex() { return RULE_pTagOpen; } 1459 @Override 1460 public void enterRule(ParseTreeListener listener) { 1461 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagOpen(this); 1462 } 1463 @Override 1464 public void exitRule(ParseTreeListener listener) { 1465 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagOpen(this); 1466 } 1467 @Override 1468 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1469 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagOpen(this); 1470 else return visitor.visitChildren(this); 1471 } 1472 } 1473 1474 public final PTagOpenContext pTagOpen() throws RecognitionException { 1475 PTagOpenContext _localctx = new PTagOpenContext(_ctx, getState()); 1476 enterRule(_localctx, 12, RULE_pTagOpen); 1477 int _la; 1478 try { 1479 enterOuterAlt(_localctx, 1); 1480 { 1481 setState(306); 1482 match(OPEN); 1483 setState(307); 1484 match(P_HTML_TAG_NAME); 1485 setState(314); 1486 _errHandler.sync(this); 1487 _la = _input.LA(1); 1488 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 1489 { 1490 setState(312); 1491 switch (_input.LA(1)) { 1492 case HTML_TAG_NAME: 1493 { 1494 setState(308); 1495 attribute(); 1496 } 1497 break; 1498 case NEWLINE: 1499 { 1500 setState(309); 1501 match(NEWLINE); 1502 } 1503 break; 1504 case LEADING_ASTERISK: 1505 { 1506 setState(310); 1507 match(LEADING_ASTERISK); 1508 } 1509 break; 1510 case WS: 1511 { 1512 setState(311); 1513 match(WS); 1514 } 1515 break; 1516 default: 1517 throw new NoViableAltException(this); 1518 } 1519 } 1520 setState(316); 1521 _errHandler.sync(this); 1522 _la = _input.LA(1); 1523 } 1524 setState(317); 1525 match(CLOSE); 1526 } 1527 } 1528 catch (RecognitionException re) { 1529 _localctx.exception = re; 1530 _errHandler.reportError(this, re); 1531 _errHandler.recover(this, re); 1532 } 1533 finally { 1534 exitRule(); 1535 } 1536 return _localctx; 1537 } 1538 1539 public static class PTagCloseContext extends ParserRuleContext { 1540 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1541 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1542 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1543 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1544 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1545 public TerminalNode NEWLINE(int i) { 1546 return getToken(JavadocParser.NEWLINE, i); 1547 } 1548 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1549 public TerminalNode LEADING_ASTERISK(int i) { 1550 return getToken(JavadocParser.LEADING_ASTERISK, i); 1551 } 1552 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1553 public TerminalNode WS(int i) { 1554 return getToken(JavadocParser.WS, i); 1555 } 1556 public PTagCloseContext(ParserRuleContext parent, int invokingState) { 1557 super(parent, invokingState); 1558 } 1559 @Override public int getRuleIndex() { return RULE_pTagClose; } 1560 @Override 1561 public void enterRule(ParseTreeListener listener) { 1562 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagClose(this); 1563 } 1564 @Override 1565 public void exitRule(ParseTreeListener listener) { 1566 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagClose(this); 1567 } 1568 @Override 1569 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1570 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagClose(this); 1571 else return visitor.visitChildren(this); 1572 } 1573 } 1574 1575 public final PTagCloseContext pTagClose() throws RecognitionException { 1576 PTagCloseContext _localctx = new PTagCloseContext(_ctx, getState()); 1577 enterRule(_localctx, 14, RULE_pTagClose); 1578 int _la; 1579 try { 1580 enterOuterAlt(_localctx, 1); 1581 { 1582 setState(319); 1583 match(OPEN); 1584 setState(320); 1585 match(SLASH); 1586 setState(321); 1587 match(P_HTML_TAG_NAME); 1588 setState(325); 1589 _errHandler.sync(this); 1590 _la = _input.LA(1); 1591 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1592 { 1593 { 1594 setState(322); 1595 _la = _input.LA(1); 1596 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1597 _errHandler.recoverInline(this); 1598 } else { 1599 consume(); 1600 } 1601 } 1602 } 1603 setState(327); 1604 _errHandler.sync(this); 1605 _la = _input.LA(1); 1606 } 1607 setState(328); 1608 match(CLOSE); 1609 } 1610 } 1611 catch (RecognitionException re) { 1612 _localctx.exception = re; 1613 _errHandler.reportError(this, re); 1614 _errHandler.recover(this, re); 1615 } 1616 finally { 1617 exitRule(); 1618 } 1619 return _localctx; 1620 } 1621 1622 public static class ParagraphContext extends ParserRuleContext { 1623 public PTagOpenContext pTagOpen() { 1624 return getRuleContext(PTagOpenContext.class,0); 1625 } 1626 public PTagCloseContext pTagClose() { 1627 return getRuleContext(PTagCloseContext.class,0); 1628 } 1629 public List<HtmlTagContext> htmlTag() { 1630 return getRuleContexts(HtmlTagContext.class); 1631 } 1632 public HtmlTagContext htmlTag(int i) { 1633 return getRuleContext(HtmlTagContext.class,i); 1634 } 1635 public List<SingletonTagContext> singletonTag() { 1636 return getRuleContexts(SingletonTagContext.class); 1637 } 1638 public SingletonTagContext singletonTag(int i) { 1639 return getRuleContext(SingletonTagContext.class,i); 1640 } 1641 public List<LiContext> li() { 1642 return getRuleContexts(LiContext.class); 1643 } 1644 public LiContext li(int i) { 1645 return getRuleContext(LiContext.class,i); 1646 } 1647 public List<TrContext> tr() { 1648 return getRuleContexts(TrContext.class); 1649 } 1650 public TrContext tr(int i) { 1651 return getRuleContext(TrContext.class,i); 1652 } 1653 public List<TdContext> td() { 1654 return getRuleContexts(TdContext.class); 1655 } 1656 public TdContext td(int i) { 1657 return getRuleContext(TdContext.class,i); 1658 } 1659 public List<ThContext> th() { 1660 return getRuleContexts(ThContext.class); 1661 } 1662 public ThContext th(int i) { 1663 return getRuleContext(ThContext.class,i); 1664 } 1665 public List<BodyContext> body() { 1666 return getRuleContexts(BodyContext.class); 1667 } 1668 public BodyContext body(int i) { 1669 return getRuleContext(BodyContext.class,i); 1670 } 1671 public List<ColgroupContext> colgroup() { 1672 return getRuleContexts(ColgroupContext.class); 1673 } 1674 public ColgroupContext colgroup(int i) { 1675 return getRuleContext(ColgroupContext.class,i); 1676 } 1677 public List<DdContext> dd() { 1678 return getRuleContexts(DdContext.class); 1679 } 1680 public DdContext dd(int i) { 1681 return getRuleContext(DdContext.class,i); 1682 } 1683 public List<DtContext> dt() { 1684 return getRuleContexts(DtContext.class); 1685 } 1686 public DtContext dt(int i) { 1687 return getRuleContext(DtContext.class,i); 1688 } 1689 public List<HeadContext> head() { 1690 return getRuleContexts(HeadContext.class); 1691 } 1692 public HeadContext head(int i) { 1693 return getRuleContext(HeadContext.class,i); 1694 } 1695 public List<HtmlContext> html() { 1696 return getRuleContexts(HtmlContext.class); 1697 } 1698 public HtmlContext html(int i) { 1699 return getRuleContext(HtmlContext.class,i); 1700 } 1701 public List<OptionContext> option() { 1702 return getRuleContexts(OptionContext.class); 1703 } 1704 public OptionContext option(int i) { 1705 return getRuleContext(OptionContext.class,i); 1706 } 1707 public List<TbodyContext> tbody() { 1708 return getRuleContexts(TbodyContext.class); 1709 } 1710 public TbodyContext tbody(int i) { 1711 return getRuleContext(TbodyContext.class,i); 1712 } 1713 public List<TheadContext> thead() { 1714 return getRuleContexts(TheadContext.class); 1715 } 1716 public TheadContext thead(int i) { 1717 return getRuleContext(TheadContext.class,i); 1718 } 1719 public List<TfootContext> tfoot() { 1720 return getRuleContexts(TfootContext.class); 1721 } 1722 public TfootContext tfoot(int i) { 1723 return getRuleContext(TfootContext.class,i); 1724 } 1725 public List<LiTagOpenContext> liTagOpen() { 1726 return getRuleContexts(LiTagOpenContext.class); 1727 } 1728 public LiTagOpenContext liTagOpen(int i) { 1729 return getRuleContext(LiTagOpenContext.class,i); 1730 } 1731 public List<TrTagOpenContext> trTagOpen() { 1732 return getRuleContexts(TrTagOpenContext.class); 1733 } 1734 public TrTagOpenContext trTagOpen(int i) { 1735 return getRuleContext(TrTagOpenContext.class,i); 1736 } 1737 public List<TdTagOpenContext> tdTagOpen() { 1738 return getRuleContexts(TdTagOpenContext.class); 1739 } 1740 public TdTagOpenContext tdTagOpen(int i) { 1741 return getRuleContext(TdTagOpenContext.class,i); 1742 } 1743 public List<ThTagOpenContext> thTagOpen() { 1744 return getRuleContexts(ThTagOpenContext.class); 1745 } 1746 public ThTagOpenContext thTagOpen(int i) { 1747 return getRuleContext(ThTagOpenContext.class,i); 1748 } 1749 public List<BodyTagOpenContext> bodyTagOpen() { 1750 return getRuleContexts(BodyTagOpenContext.class); 1751 } 1752 public BodyTagOpenContext bodyTagOpen(int i) { 1753 return getRuleContext(BodyTagOpenContext.class,i); 1754 } 1755 public List<ColgroupTagOpenContext> colgroupTagOpen() { 1756 return getRuleContexts(ColgroupTagOpenContext.class); 1757 } 1758 public ColgroupTagOpenContext colgroupTagOpen(int i) { 1759 return getRuleContext(ColgroupTagOpenContext.class,i); 1760 } 1761 public List<DdTagOpenContext> ddTagOpen() { 1762 return getRuleContexts(DdTagOpenContext.class); 1763 } 1764 public DdTagOpenContext ddTagOpen(int i) { 1765 return getRuleContext(DdTagOpenContext.class,i); 1766 } 1767 public List<DtTagOpenContext> dtTagOpen() { 1768 return getRuleContexts(DtTagOpenContext.class); 1769 } 1770 public DtTagOpenContext dtTagOpen(int i) { 1771 return getRuleContext(DtTagOpenContext.class,i); 1772 } 1773 public List<HeadTagOpenContext> headTagOpen() { 1774 return getRuleContexts(HeadTagOpenContext.class); 1775 } 1776 public HeadTagOpenContext headTagOpen(int i) { 1777 return getRuleContext(HeadTagOpenContext.class,i); 1778 } 1779 public List<HtmlTagOpenContext> htmlTagOpen() { 1780 return getRuleContexts(HtmlTagOpenContext.class); 1781 } 1782 public HtmlTagOpenContext htmlTagOpen(int i) { 1783 return getRuleContext(HtmlTagOpenContext.class,i); 1784 } 1785 public List<OptionTagOpenContext> optionTagOpen() { 1786 return getRuleContexts(OptionTagOpenContext.class); 1787 } 1788 public OptionTagOpenContext optionTagOpen(int i) { 1789 return getRuleContext(OptionTagOpenContext.class,i); 1790 } 1791 public List<TbodyTagOpenContext> tbodyTagOpen() { 1792 return getRuleContexts(TbodyTagOpenContext.class); 1793 } 1794 public TbodyTagOpenContext tbodyTagOpen(int i) { 1795 return getRuleContext(TbodyTagOpenContext.class,i); 1796 } 1797 public List<TheadTagOpenContext> theadTagOpen() { 1798 return getRuleContexts(TheadTagOpenContext.class); 1799 } 1800 public TheadTagOpenContext theadTagOpen(int i) { 1801 return getRuleContext(TheadTagOpenContext.class,i); 1802 } 1803 public List<TfootTagOpenContext> tfootTagOpen() { 1804 return getRuleContexts(TfootTagOpenContext.class); 1805 } 1806 public TfootTagOpenContext tfootTagOpen(int i) { 1807 return getRuleContext(TfootTagOpenContext.class,i); 1808 } 1809 public List<HtmlCommentContext> htmlComment() { 1810 return getRuleContexts(HtmlCommentContext.class); 1811 } 1812 public HtmlCommentContext htmlComment(int i) { 1813 return getRuleContext(HtmlCommentContext.class,i); 1814 } 1815 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1816 public TerminalNode CDATA(int i) { 1817 return getToken(JavadocParser.CDATA, i); 1818 } 1819 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1820 public TerminalNode NEWLINE(int i) { 1821 return getToken(JavadocParser.NEWLINE, i); 1822 } 1823 public List<TextContext> text() { 1824 return getRuleContexts(TextContext.class); 1825 } 1826 public TextContext text(int i) { 1827 return getRuleContext(TextContext.class,i); 1828 } 1829 public List<JavadocInlineTagContext> javadocInlineTag() { 1830 return getRuleContexts(JavadocInlineTagContext.class); 1831 } 1832 public JavadocInlineTagContext javadocInlineTag(int i) { 1833 return getRuleContext(JavadocInlineTagContext.class,i); 1834 } 1835 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1836 public TerminalNode LEADING_ASTERISK(int i) { 1837 return getToken(JavadocParser.LEADING_ASTERISK, i); 1838 } 1839 public ParagraphContext(ParserRuleContext parent, int invokingState) { 1840 super(parent, invokingState); 1841 } 1842 @Override public int getRuleIndex() { return RULE_paragraph; } 1843 @Override 1844 public void enterRule(ParseTreeListener listener) { 1845 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParagraph(this); 1846 } 1847 @Override 1848 public void exitRule(ParseTreeListener listener) { 1849 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParagraph(this); 1850 } 1851 @Override 1852 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1853 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParagraph(this); 1854 else return visitor.visitChildren(this); 1855 } 1856 } 1857 1858 public final ParagraphContext paragraph() throws RecognitionException { 1859 ParagraphContext _localctx = new ParagraphContext(_ctx, getState()); 1860 enterRule(_localctx, 16, RULE_paragraph); 1861 try { 1862 int _alt; 1863 enterOuterAlt(_localctx, 1); 1864 { 1865 setState(330); 1866 pTagOpen(); 1867 setState(370); 1868 _errHandler.sync(this); 1869 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 1870 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1871 if ( _alt==1 ) { 1872 { 1873 setState(368); 1874 switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) { 1875 case 1: 1876 { 1877 setState(331); 1878 htmlTag(); 1879 } 1880 break; 1881 case 2: 1882 { 1883 setState(332); 1884 singletonTag(); 1885 } 1886 break; 1887 case 3: 1888 { 1889 setState(333); 1890 li(); 1891 } 1892 break; 1893 case 4: 1894 { 1895 setState(334); 1896 tr(); 1897 } 1898 break; 1899 case 5: 1900 { 1901 setState(335); 1902 td(); 1903 } 1904 break; 1905 case 6: 1906 { 1907 setState(336); 1908 th(); 1909 } 1910 break; 1911 case 7: 1912 { 1913 setState(337); 1914 body(); 1915 } 1916 break; 1917 case 8: 1918 { 1919 setState(338); 1920 colgroup(); 1921 } 1922 break; 1923 case 9: 1924 { 1925 setState(339); 1926 dd(); 1927 } 1928 break; 1929 case 10: 1930 { 1931 setState(340); 1932 dt(); 1933 } 1934 break; 1935 case 11: 1936 { 1937 setState(341); 1938 head(); 1939 } 1940 break; 1941 case 12: 1942 { 1943 setState(342); 1944 html(); 1945 } 1946 break; 1947 case 13: 1948 { 1949 setState(343); 1950 option(); 1951 } 1952 break; 1953 case 14: 1954 { 1955 setState(344); 1956 tbody(); 1957 } 1958 break; 1959 case 15: 1960 { 1961 setState(345); 1962 thead(); 1963 } 1964 break; 1965 case 16: 1966 { 1967 setState(346); 1968 tfoot(); 1969 } 1970 break; 1971 case 17: 1972 { 1973 setState(347); 1974 liTagOpen(); 1975 } 1976 break; 1977 case 18: 1978 { 1979 setState(348); 1980 trTagOpen(); 1981 } 1982 break; 1983 case 19: 1984 { 1985 setState(349); 1986 tdTagOpen(); 1987 } 1988 break; 1989 case 20: 1990 { 1991 setState(350); 1992 thTagOpen(); 1993 } 1994 break; 1995 case 21: 1996 { 1997 setState(351); 1998 bodyTagOpen(); 1999 } 2000 break; 2001 case 22: 2002 { 2003 setState(352); 2004 colgroupTagOpen(); 2005 } 2006 break; 2007 case 23: 2008 { 2009 setState(353); 2010 ddTagOpen(); 2011 } 2012 break; 2013 case 24: 2014 { 2015 setState(354); 2016 dtTagOpen(); 2017 } 2018 break; 2019 case 25: 2020 { 2021 setState(355); 2022 headTagOpen(); 2023 } 2024 break; 2025 case 26: 2026 { 2027 setState(356); 2028 htmlTagOpen(); 2029 } 2030 break; 2031 case 27: 2032 { 2033 setState(357); 2034 optionTagOpen(); 2035 } 2036 break; 2037 case 28: 2038 { 2039 setState(358); 2040 tbodyTagOpen(); 2041 } 2042 break; 2043 case 29: 2044 { 2045 setState(359); 2046 theadTagOpen(); 2047 } 2048 break; 2049 case 30: 2050 { 2051 setState(360); 2052 tfootTagOpen(); 2053 } 2054 break; 2055 case 31: 2056 { 2057 { 2058 setState(361); 2059 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2060 setState(362); 2061 match(LEADING_ASTERISK); 2062 } 2063 } 2064 break; 2065 case 32: 2066 { 2067 setState(363); 2068 htmlComment(); 2069 } 2070 break; 2071 case 33: 2072 { 2073 setState(364); 2074 match(CDATA); 2075 } 2076 break; 2077 case 34: 2078 { 2079 setState(365); 2080 match(NEWLINE); 2081 } 2082 break; 2083 case 35: 2084 { 2085 setState(366); 2086 text(); 2087 } 2088 break; 2089 case 36: 2090 { 2091 setState(367); 2092 javadocInlineTag(); 2093 } 2094 break; 2095 } 2096 } 2097 } 2098 setState(372); 2099 _errHandler.sync(this); 2100 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 2101 } 2102 setState(373); 2103 pTagClose(); 2104 } 2105 } 2106 catch (RecognitionException re) { 2107 _localctx.exception = re; 2108 _errHandler.reportError(this, re); 2109 _errHandler.recover(this, re); 2110 } 2111 finally { 2112 exitRule(); 2113 } 2114 return _localctx; 2115 } 2116 2117 public static class LiTagOpenContext extends ParserRuleContext { 2118 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2119 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2120 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2121 public List<AttributeContext> attribute() { 2122 return getRuleContexts(AttributeContext.class); 2123 } 2124 public AttributeContext attribute(int i) { 2125 return getRuleContext(AttributeContext.class,i); 2126 } 2127 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2128 public TerminalNode NEWLINE(int i) { 2129 return getToken(JavadocParser.NEWLINE, i); 2130 } 2131 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2132 public TerminalNode LEADING_ASTERISK(int i) { 2133 return getToken(JavadocParser.LEADING_ASTERISK, i); 2134 } 2135 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2136 public TerminalNode WS(int i) { 2137 return getToken(JavadocParser.WS, i); 2138 } 2139 public LiTagOpenContext(ParserRuleContext parent, int invokingState) { 2140 super(parent, invokingState); 2141 } 2142 @Override public int getRuleIndex() { return RULE_liTagOpen; } 2143 @Override 2144 public void enterRule(ParseTreeListener listener) { 2145 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagOpen(this); 2146 } 2147 @Override 2148 public void exitRule(ParseTreeListener listener) { 2149 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagOpen(this); 2150 } 2151 @Override 2152 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2153 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagOpen(this); 2154 else return visitor.visitChildren(this); 2155 } 2156 } 2157 2158 public final LiTagOpenContext liTagOpen() throws RecognitionException { 2159 LiTagOpenContext _localctx = new LiTagOpenContext(_ctx, getState()); 2160 enterRule(_localctx, 18, RULE_liTagOpen); 2161 int _la; 2162 try { 2163 enterOuterAlt(_localctx, 1); 2164 { 2165 setState(375); 2166 match(OPEN); 2167 setState(376); 2168 match(LI_HTML_TAG_NAME); 2169 setState(383); 2170 _errHandler.sync(this); 2171 _la = _input.LA(1); 2172 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2173 { 2174 setState(381); 2175 switch (_input.LA(1)) { 2176 case HTML_TAG_NAME: 2177 { 2178 setState(377); 2179 attribute(); 2180 } 2181 break; 2182 case NEWLINE: 2183 { 2184 setState(378); 2185 match(NEWLINE); 2186 } 2187 break; 2188 case LEADING_ASTERISK: 2189 { 2190 setState(379); 2191 match(LEADING_ASTERISK); 2192 } 2193 break; 2194 case WS: 2195 { 2196 setState(380); 2197 match(WS); 2198 } 2199 break; 2200 default: 2201 throw new NoViableAltException(this); 2202 } 2203 } 2204 setState(385); 2205 _errHandler.sync(this); 2206 _la = _input.LA(1); 2207 } 2208 setState(386); 2209 match(CLOSE); 2210 } 2211 } 2212 catch (RecognitionException re) { 2213 _localctx.exception = re; 2214 _errHandler.reportError(this, re); 2215 _errHandler.recover(this, re); 2216 } 2217 finally { 2218 exitRule(); 2219 } 2220 return _localctx; 2221 } 2222 2223 public static class LiTagCloseContext extends ParserRuleContext { 2224 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2225 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2226 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2227 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2228 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2229 public TerminalNode NEWLINE(int i) { 2230 return getToken(JavadocParser.NEWLINE, i); 2231 } 2232 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2233 public TerminalNode LEADING_ASTERISK(int i) { 2234 return getToken(JavadocParser.LEADING_ASTERISK, i); 2235 } 2236 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2237 public TerminalNode WS(int i) { 2238 return getToken(JavadocParser.WS, i); 2239 } 2240 public LiTagCloseContext(ParserRuleContext parent, int invokingState) { 2241 super(parent, invokingState); 2242 } 2243 @Override public int getRuleIndex() { return RULE_liTagClose; } 2244 @Override 2245 public void enterRule(ParseTreeListener listener) { 2246 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagClose(this); 2247 } 2248 @Override 2249 public void exitRule(ParseTreeListener listener) { 2250 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagClose(this); 2251 } 2252 @Override 2253 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2254 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagClose(this); 2255 else return visitor.visitChildren(this); 2256 } 2257 } 2258 2259 public final LiTagCloseContext liTagClose() throws RecognitionException { 2260 LiTagCloseContext _localctx = new LiTagCloseContext(_ctx, getState()); 2261 enterRule(_localctx, 20, RULE_liTagClose); 2262 int _la; 2263 try { 2264 enterOuterAlt(_localctx, 1); 2265 { 2266 setState(388); 2267 match(OPEN); 2268 setState(389); 2269 match(SLASH); 2270 setState(390); 2271 match(LI_HTML_TAG_NAME); 2272 setState(394); 2273 _errHandler.sync(this); 2274 _la = _input.LA(1); 2275 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2276 { 2277 { 2278 setState(391); 2279 _la = _input.LA(1); 2280 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2281 _errHandler.recoverInline(this); 2282 } else { 2283 consume(); 2284 } 2285 } 2286 } 2287 setState(396); 2288 _errHandler.sync(this); 2289 _la = _input.LA(1); 2290 } 2291 setState(397); 2292 match(CLOSE); 2293 } 2294 } 2295 catch (RecognitionException re) { 2296 _localctx.exception = re; 2297 _errHandler.reportError(this, re); 2298 _errHandler.recover(this, re); 2299 } 2300 finally { 2301 exitRule(); 2302 } 2303 return _localctx; 2304 } 2305 2306 public static class LiContext extends ParserRuleContext { 2307 public LiTagOpenContext liTagOpen() { 2308 return getRuleContext(LiTagOpenContext.class,0); 2309 } 2310 public LiTagCloseContext liTagClose() { 2311 return getRuleContext(LiTagCloseContext.class,0); 2312 } 2313 public List<HtmlTagContext> htmlTag() { 2314 return getRuleContexts(HtmlTagContext.class); 2315 } 2316 public HtmlTagContext htmlTag(int i) { 2317 return getRuleContext(HtmlTagContext.class,i); 2318 } 2319 public List<SingletonTagContext> singletonTag() { 2320 return getRuleContexts(SingletonTagContext.class); 2321 } 2322 public SingletonTagContext singletonTag(int i) { 2323 return getRuleContext(SingletonTagContext.class,i); 2324 } 2325 public List<ParagraphContext> paragraph() { 2326 return getRuleContexts(ParagraphContext.class); 2327 } 2328 public ParagraphContext paragraph(int i) { 2329 return getRuleContext(ParagraphContext.class,i); 2330 } 2331 public List<TrContext> tr() { 2332 return getRuleContexts(TrContext.class); 2333 } 2334 public TrContext tr(int i) { 2335 return getRuleContext(TrContext.class,i); 2336 } 2337 public List<TdContext> td() { 2338 return getRuleContexts(TdContext.class); 2339 } 2340 public TdContext td(int i) { 2341 return getRuleContext(TdContext.class,i); 2342 } 2343 public List<ThContext> th() { 2344 return getRuleContexts(ThContext.class); 2345 } 2346 public ThContext th(int i) { 2347 return getRuleContext(ThContext.class,i); 2348 } 2349 public List<BodyContext> body() { 2350 return getRuleContexts(BodyContext.class); 2351 } 2352 public BodyContext body(int i) { 2353 return getRuleContext(BodyContext.class,i); 2354 } 2355 public List<ColgroupContext> colgroup() { 2356 return getRuleContexts(ColgroupContext.class); 2357 } 2358 public ColgroupContext colgroup(int i) { 2359 return getRuleContext(ColgroupContext.class,i); 2360 } 2361 public List<DdContext> dd() { 2362 return getRuleContexts(DdContext.class); 2363 } 2364 public DdContext dd(int i) { 2365 return getRuleContext(DdContext.class,i); 2366 } 2367 public List<DtContext> dt() { 2368 return getRuleContexts(DtContext.class); 2369 } 2370 public DtContext dt(int i) { 2371 return getRuleContext(DtContext.class,i); 2372 } 2373 public List<HeadContext> head() { 2374 return getRuleContexts(HeadContext.class); 2375 } 2376 public HeadContext head(int i) { 2377 return getRuleContext(HeadContext.class,i); 2378 } 2379 public List<HtmlContext> html() { 2380 return getRuleContexts(HtmlContext.class); 2381 } 2382 public HtmlContext html(int i) { 2383 return getRuleContext(HtmlContext.class,i); 2384 } 2385 public List<OptionContext> option() { 2386 return getRuleContexts(OptionContext.class); 2387 } 2388 public OptionContext option(int i) { 2389 return getRuleContext(OptionContext.class,i); 2390 } 2391 public List<TbodyContext> tbody() { 2392 return getRuleContexts(TbodyContext.class); 2393 } 2394 public TbodyContext tbody(int i) { 2395 return getRuleContext(TbodyContext.class,i); 2396 } 2397 public List<TheadContext> thead() { 2398 return getRuleContexts(TheadContext.class); 2399 } 2400 public TheadContext thead(int i) { 2401 return getRuleContext(TheadContext.class,i); 2402 } 2403 public List<TfootContext> tfoot() { 2404 return getRuleContexts(TfootContext.class); 2405 } 2406 public TfootContext tfoot(int i) { 2407 return getRuleContext(TfootContext.class,i); 2408 } 2409 public List<PTagOpenContext> pTagOpen() { 2410 return getRuleContexts(PTagOpenContext.class); 2411 } 2412 public PTagOpenContext pTagOpen(int i) { 2413 return getRuleContext(PTagOpenContext.class,i); 2414 } 2415 public List<TrTagOpenContext> trTagOpen() { 2416 return getRuleContexts(TrTagOpenContext.class); 2417 } 2418 public TrTagOpenContext trTagOpen(int i) { 2419 return getRuleContext(TrTagOpenContext.class,i); 2420 } 2421 public List<TdTagOpenContext> tdTagOpen() { 2422 return getRuleContexts(TdTagOpenContext.class); 2423 } 2424 public TdTagOpenContext tdTagOpen(int i) { 2425 return getRuleContext(TdTagOpenContext.class,i); 2426 } 2427 public List<ThTagOpenContext> thTagOpen() { 2428 return getRuleContexts(ThTagOpenContext.class); 2429 } 2430 public ThTagOpenContext thTagOpen(int i) { 2431 return getRuleContext(ThTagOpenContext.class,i); 2432 } 2433 public List<BodyTagOpenContext> bodyTagOpen() { 2434 return getRuleContexts(BodyTagOpenContext.class); 2435 } 2436 public BodyTagOpenContext bodyTagOpen(int i) { 2437 return getRuleContext(BodyTagOpenContext.class,i); 2438 } 2439 public List<ColgroupTagOpenContext> colgroupTagOpen() { 2440 return getRuleContexts(ColgroupTagOpenContext.class); 2441 } 2442 public ColgroupTagOpenContext colgroupTagOpen(int i) { 2443 return getRuleContext(ColgroupTagOpenContext.class,i); 2444 } 2445 public List<DdTagOpenContext> ddTagOpen() { 2446 return getRuleContexts(DdTagOpenContext.class); 2447 } 2448 public DdTagOpenContext ddTagOpen(int i) { 2449 return getRuleContext(DdTagOpenContext.class,i); 2450 } 2451 public List<DtTagOpenContext> dtTagOpen() { 2452 return getRuleContexts(DtTagOpenContext.class); 2453 } 2454 public DtTagOpenContext dtTagOpen(int i) { 2455 return getRuleContext(DtTagOpenContext.class,i); 2456 } 2457 public List<HeadTagOpenContext> headTagOpen() { 2458 return getRuleContexts(HeadTagOpenContext.class); 2459 } 2460 public HeadTagOpenContext headTagOpen(int i) { 2461 return getRuleContext(HeadTagOpenContext.class,i); 2462 } 2463 public List<HtmlTagOpenContext> htmlTagOpen() { 2464 return getRuleContexts(HtmlTagOpenContext.class); 2465 } 2466 public HtmlTagOpenContext htmlTagOpen(int i) { 2467 return getRuleContext(HtmlTagOpenContext.class,i); 2468 } 2469 public List<OptionTagOpenContext> optionTagOpen() { 2470 return getRuleContexts(OptionTagOpenContext.class); 2471 } 2472 public OptionTagOpenContext optionTagOpen(int i) { 2473 return getRuleContext(OptionTagOpenContext.class,i); 2474 } 2475 public List<TbodyTagOpenContext> tbodyTagOpen() { 2476 return getRuleContexts(TbodyTagOpenContext.class); 2477 } 2478 public TbodyTagOpenContext tbodyTagOpen(int i) { 2479 return getRuleContext(TbodyTagOpenContext.class,i); 2480 } 2481 public List<TheadTagOpenContext> theadTagOpen() { 2482 return getRuleContexts(TheadTagOpenContext.class); 2483 } 2484 public TheadTagOpenContext theadTagOpen(int i) { 2485 return getRuleContext(TheadTagOpenContext.class,i); 2486 } 2487 public List<TfootTagOpenContext> tfootTagOpen() { 2488 return getRuleContexts(TfootTagOpenContext.class); 2489 } 2490 public TfootTagOpenContext tfootTagOpen(int i) { 2491 return getRuleContext(TfootTagOpenContext.class,i); 2492 } 2493 public List<HtmlCommentContext> htmlComment() { 2494 return getRuleContexts(HtmlCommentContext.class); 2495 } 2496 public HtmlCommentContext htmlComment(int i) { 2497 return getRuleContext(HtmlCommentContext.class,i); 2498 } 2499 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 2500 public TerminalNode CDATA(int i) { 2501 return getToken(JavadocParser.CDATA, i); 2502 } 2503 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2504 public TerminalNode NEWLINE(int i) { 2505 return getToken(JavadocParser.NEWLINE, i); 2506 } 2507 public List<TextContext> text() { 2508 return getRuleContexts(TextContext.class); 2509 } 2510 public TextContext text(int i) { 2511 return getRuleContext(TextContext.class,i); 2512 } 2513 public List<JavadocInlineTagContext> javadocInlineTag() { 2514 return getRuleContexts(JavadocInlineTagContext.class); 2515 } 2516 public JavadocInlineTagContext javadocInlineTag(int i) { 2517 return getRuleContext(JavadocInlineTagContext.class,i); 2518 } 2519 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2520 public TerminalNode LEADING_ASTERISK(int i) { 2521 return getToken(JavadocParser.LEADING_ASTERISK, i); 2522 } 2523 public LiContext(ParserRuleContext parent, int invokingState) { 2524 super(parent, invokingState); 2525 } 2526 @Override public int getRuleIndex() { return RULE_li; } 2527 @Override 2528 public void enterRule(ParseTreeListener listener) { 2529 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLi(this); 2530 } 2531 @Override 2532 public void exitRule(ParseTreeListener listener) { 2533 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLi(this); 2534 } 2535 @Override 2536 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2537 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLi(this); 2538 else return visitor.visitChildren(this); 2539 } 2540 } 2541 2542 public final LiContext li() throws RecognitionException { 2543 LiContext _localctx = new LiContext(_ctx, getState()); 2544 enterRule(_localctx, 22, RULE_li); 2545 try { 2546 int _alt; 2547 enterOuterAlt(_localctx, 1); 2548 { 2549 setState(399); 2550 liTagOpen(); 2551 setState(439); 2552 _errHandler.sync(this); 2553 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 2554 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 2555 if ( _alt==1 ) { 2556 { 2557 setState(437); 2558 switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) { 2559 case 1: 2560 { 2561 setState(400); 2562 htmlTag(); 2563 } 2564 break; 2565 case 2: 2566 { 2567 setState(401); 2568 singletonTag(); 2569 } 2570 break; 2571 case 3: 2572 { 2573 setState(402); 2574 paragraph(); 2575 } 2576 break; 2577 case 4: 2578 { 2579 setState(403); 2580 tr(); 2581 } 2582 break; 2583 case 5: 2584 { 2585 setState(404); 2586 td(); 2587 } 2588 break; 2589 case 6: 2590 { 2591 setState(405); 2592 th(); 2593 } 2594 break; 2595 case 7: 2596 { 2597 setState(406); 2598 body(); 2599 } 2600 break; 2601 case 8: 2602 { 2603 setState(407); 2604 colgroup(); 2605 } 2606 break; 2607 case 9: 2608 { 2609 setState(408); 2610 dd(); 2611 } 2612 break; 2613 case 10: 2614 { 2615 setState(409); 2616 dt(); 2617 } 2618 break; 2619 case 11: 2620 { 2621 setState(410); 2622 head(); 2623 } 2624 break; 2625 case 12: 2626 { 2627 setState(411); 2628 html(); 2629 } 2630 break; 2631 case 13: 2632 { 2633 setState(412); 2634 option(); 2635 } 2636 break; 2637 case 14: 2638 { 2639 setState(413); 2640 tbody(); 2641 } 2642 break; 2643 case 15: 2644 { 2645 setState(414); 2646 thead(); 2647 } 2648 break; 2649 case 16: 2650 { 2651 setState(415); 2652 tfoot(); 2653 } 2654 break; 2655 case 17: 2656 { 2657 setState(416); 2658 pTagOpen(); 2659 } 2660 break; 2661 case 18: 2662 { 2663 setState(417); 2664 trTagOpen(); 2665 } 2666 break; 2667 case 19: 2668 { 2669 setState(418); 2670 tdTagOpen(); 2671 } 2672 break; 2673 case 20: 2674 { 2675 setState(419); 2676 thTagOpen(); 2677 } 2678 break; 2679 case 21: 2680 { 2681 setState(420); 2682 bodyTagOpen(); 2683 } 2684 break; 2685 case 22: 2686 { 2687 setState(421); 2688 colgroupTagOpen(); 2689 } 2690 break; 2691 case 23: 2692 { 2693 setState(422); 2694 ddTagOpen(); 2695 } 2696 break; 2697 case 24: 2698 { 2699 setState(423); 2700 dtTagOpen(); 2701 } 2702 break; 2703 case 25: 2704 { 2705 setState(424); 2706 headTagOpen(); 2707 } 2708 break; 2709 case 26: 2710 { 2711 setState(425); 2712 htmlTagOpen(); 2713 } 2714 break; 2715 case 27: 2716 { 2717 setState(426); 2718 optionTagOpen(); 2719 } 2720 break; 2721 case 28: 2722 { 2723 setState(427); 2724 tbodyTagOpen(); 2725 } 2726 break; 2727 case 29: 2728 { 2729 setState(428); 2730 theadTagOpen(); 2731 } 2732 break; 2733 case 30: 2734 { 2735 setState(429); 2736 tfootTagOpen(); 2737 } 2738 break; 2739 case 31: 2740 { 2741 { 2742 setState(430); 2743 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2744 setState(431); 2745 match(LEADING_ASTERISK); 2746 } 2747 } 2748 break; 2749 case 32: 2750 { 2751 setState(432); 2752 htmlComment(); 2753 } 2754 break; 2755 case 33: 2756 { 2757 setState(433); 2758 match(CDATA); 2759 } 2760 break; 2761 case 34: 2762 { 2763 setState(434); 2764 match(NEWLINE); 2765 } 2766 break; 2767 case 35: 2768 { 2769 setState(435); 2770 text(); 2771 } 2772 break; 2773 case 36: 2774 { 2775 setState(436); 2776 javadocInlineTag(); 2777 } 2778 break; 2779 } 2780 } 2781 } 2782 setState(441); 2783 _errHandler.sync(this); 2784 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 2785 } 2786 setState(442); 2787 liTagClose(); 2788 } 2789 } 2790 catch (RecognitionException re) { 2791 _localctx.exception = re; 2792 _errHandler.reportError(this, re); 2793 _errHandler.recover(this, re); 2794 } 2795 finally { 2796 exitRule(); 2797 } 2798 return _localctx; 2799 } 2800 2801 public static class TrTagOpenContext extends ParserRuleContext { 2802 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2803 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2804 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2805 public List<AttributeContext> attribute() { 2806 return getRuleContexts(AttributeContext.class); 2807 } 2808 public AttributeContext attribute(int i) { 2809 return getRuleContext(AttributeContext.class,i); 2810 } 2811 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2812 public TerminalNode NEWLINE(int i) { 2813 return getToken(JavadocParser.NEWLINE, i); 2814 } 2815 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2816 public TerminalNode LEADING_ASTERISK(int i) { 2817 return getToken(JavadocParser.LEADING_ASTERISK, i); 2818 } 2819 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2820 public TerminalNode WS(int i) { 2821 return getToken(JavadocParser.WS, i); 2822 } 2823 public TrTagOpenContext(ParserRuleContext parent, int invokingState) { 2824 super(parent, invokingState); 2825 } 2826 @Override public int getRuleIndex() { return RULE_trTagOpen; } 2827 @Override 2828 public void enterRule(ParseTreeListener listener) { 2829 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagOpen(this); 2830 } 2831 @Override 2832 public void exitRule(ParseTreeListener listener) { 2833 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagOpen(this); 2834 } 2835 @Override 2836 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2837 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagOpen(this); 2838 else return visitor.visitChildren(this); 2839 } 2840 } 2841 2842 public final TrTagOpenContext trTagOpen() throws RecognitionException { 2843 TrTagOpenContext _localctx = new TrTagOpenContext(_ctx, getState()); 2844 enterRule(_localctx, 24, RULE_trTagOpen); 2845 int _la; 2846 try { 2847 enterOuterAlt(_localctx, 1); 2848 { 2849 setState(444); 2850 match(OPEN); 2851 setState(445); 2852 match(TR_HTML_TAG_NAME); 2853 setState(452); 2854 _errHandler.sync(this); 2855 _la = _input.LA(1); 2856 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2857 { 2858 setState(450); 2859 switch (_input.LA(1)) { 2860 case HTML_TAG_NAME: 2861 { 2862 setState(446); 2863 attribute(); 2864 } 2865 break; 2866 case NEWLINE: 2867 { 2868 setState(447); 2869 match(NEWLINE); 2870 } 2871 break; 2872 case LEADING_ASTERISK: 2873 { 2874 setState(448); 2875 match(LEADING_ASTERISK); 2876 } 2877 break; 2878 case WS: 2879 { 2880 setState(449); 2881 match(WS); 2882 } 2883 break; 2884 default: 2885 throw new NoViableAltException(this); 2886 } 2887 } 2888 setState(454); 2889 _errHandler.sync(this); 2890 _la = _input.LA(1); 2891 } 2892 setState(455); 2893 match(CLOSE); 2894 } 2895 } 2896 catch (RecognitionException re) { 2897 _localctx.exception = re; 2898 _errHandler.reportError(this, re); 2899 _errHandler.recover(this, re); 2900 } 2901 finally { 2902 exitRule(); 2903 } 2904 return _localctx; 2905 } 2906 2907 public static class TrTagCloseContext extends ParserRuleContext { 2908 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2909 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2910 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2911 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2912 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2913 public TerminalNode NEWLINE(int i) { 2914 return getToken(JavadocParser.NEWLINE, i); 2915 } 2916 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2917 public TerminalNode LEADING_ASTERISK(int i) { 2918 return getToken(JavadocParser.LEADING_ASTERISK, i); 2919 } 2920 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2921 public TerminalNode WS(int i) { 2922 return getToken(JavadocParser.WS, i); 2923 } 2924 public TrTagCloseContext(ParserRuleContext parent, int invokingState) { 2925 super(parent, invokingState); 2926 } 2927 @Override public int getRuleIndex() { return RULE_trTagClose; } 2928 @Override 2929 public void enterRule(ParseTreeListener listener) { 2930 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagClose(this); 2931 } 2932 @Override 2933 public void exitRule(ParseTreeListener listener) { 2934 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagClose(this); 2935 } 2936 @Override 2937 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2938 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagClose(this); 2939 else return visitor.visitChildren(this); 2940 } 2941 } 2942 2943 public final TrTagCloseContext trTagClose() throws RecognitionException { 2944 TrTagCloseContext _localctx = new TrTagCloseContext(_ctx, getState()); 2945 enterRule(_localctx, 26, RULE_trTagClose); 2946 int _la; 2947 try { 2948 enterOuterAlt(_localctx, 1); 2949 { 2950 setState(457); 2951 match(OPEN); 2952 setState(458); 2953 match(SLASH); 2954 setState(459); 2955 match(TR_HTML_TAG_NAME); 2956 setState(463); 2957 _errHandler.sync(this); 2958 _la = _input.LA(1); 2959 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2960 { 2961 { 2962 setState(460); 2963 _la = _input.LA(1); 2964 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2965 _errHandler.recoverInline(this); 2966 } else { 2967 consume(); 2968 } 2969 } 2970 } 2971 setState(465); 2972 _errHandler.sync(this); 2973 _la = _input.LA(1); 2974 } 2975 setState(466); 2976 match(CLOSE); 2977 } 2978 } 2979 catch (RecognitionException re) { 2980 _localctx.exception = re; 2981 _errHandler.reportError(this, re); 2982 _errHandler.recover(this, re); 2983 } 2984 finally { 2985 exitRule(); 2986 } 2987 return _localctx; 2988 } 2989 2990 public static class TrContext extends ParserRuleContext { 2991 public TrTagOpenContext trTagOpen() { 2992 return getRuleContext(TrTagOpenContext.class,0); 2993 } 2994 public TrTagCloseContext trTagClose() { 2995 return getRuleContext(TrTagCloseContext.class,0); 2996 } 2997 public List<HtmlTagContext> htmlTag() { 2998 return getRuleContexts(HtmlTagContext.class); 2999 } 3000 public HtmlTagContext htmlTag(int i) { 3001 return getRuleContext(HtmlTagContext.class,i); 3002 } 3003 public List<SingletonTagContext> singletonTag() { 3004 return getRuleContexts(SingletonTagContext.class); 3005 } 3006 public SingletonTagContext singletonTag(int i) { 3007 return getRuleContext(SingletonTagContext.class,i); 3008 } 3009 public List<ParagraphContext> paragraph() { 3010 return getRuleContexts(ParagraphContext.class); 3011 } 3012 public ParagraphContext paragraph(int i) { 3013 return getRuleContext(ParagraphContext.class,i); 3014 } 3015 public List<LiContext> li() { 3016 return getRuleContexts(LiContext.class); 3017 } 3018 public LiContext li(int i) { 3019 return getRuleContext(LiContext.class,i); 3020 } 3021 public List<TdContext> td() { 3022 return getRuleContexts(TdContext.class); 3023 } 3024 public TdContext td(int i) { 3025 return getRuleContext(TdContext.class,i); 3026 } 3027 public List<ThContext> th() { 3028 return getRuleContexts(ThContext.class); 3029 } 3030 public ThContext th(int i) { 3031 return getRuleContext(ThContext.class,i); 3032 } 3033 public List<BodyContext> body() { 3034 return getRuleContexts(BodyContext.class); 3035 } 3036 public BodyContext body(int i) { 3037 return getRuleContext(BodyContext.class,i); 3038 } 3039 public List<ColgroupContext> colgroup() { 3040 return getRuleContexts(ColgroupContext.class); 3041 } 3042 public ColgroupContext colgroup(int i) { 3043 return getRuleContext(ColgroupContext.class,i); 3044 } 3045 public List<DdContext> dd() { 3046 return getRuleContexts(DdContext.class); 3047 } 3048 public DdContext dd(int i) { 3049 return getRuleContext(DdContext.class,i); 3050 } 3051 public List<DtContext> dt() { 3052 return getRuleContexts(DtContext.class); 3053 } 3054 public DtContext dt(int i) { 3055 return getRuleContext(DtContext.class,i); 3056 } 3057 public List<HeadContext> head() { 3058 return getRuleContexts(HeadContext.class); 3059 } 3060 public HeadContext head(int i) { 3061 return getRuleContext(HeadContext.class,i); 3062 } 3063 public List<HtmlContext> html() { 3064 return getRuleContexts(HtmlContext.class); 3065 } 3066 public HtmlContext html(int i) { 3067 return getRuleContext(HtmlContext.class,i); 3068 } 3069 public List<OptionContext> option() { 3070 return getRuleContexts(OptionContext.class); 3071 } 3072 public OptionContext option(int i) { 3073 return getRuleContext(OptionContext.class,i); 3074 } 3075 public List<TbodyContext> tbody() { 3076 return getRuleContexts(TbodyContext.class); 3077 } 3078 public TbodyContext tbody(int i) { 3079 return getRuleContext(TbodyContext.class,i); 3080 } 3081 public List<TheadContext> thead() { 3082 return getRuleContexts(TheadContext.class); 3083 } 3084 public TheadContext thead(int i) { 3085 return getRuleContext(TheadContext.class,i); 3086 } 3087 public List<TfootContext> tfoot() { 3088 return getRuleContexts(TfootContext.class); 3089 } 3090 public TfootContext tfoot(int i) { 3091 return getRuleContext(TfootContext.class,i); 3092 } 3093 public List<PTagOpenContext> pTagOpen() { 3094 return getRuleContexts(PTagOpenContext.class); 3095 } 3096 public PTagOpenContext pTagOpen(int i) { 3097 return getRuleContext(PTagOpenContext.class,i); 3098 } 3099 public List<LiTagOpenContext> liTagOpen() { 3100 return getRuleContexts(LiTagOpenContext.class); 3101 } 3102 public LiTagOpenContext liTagOpen(int i) { 3103 return getRuleContext(LiTagOpenContext.class,i); 3104 } 3105 public List<TdTagOpenContext> tdTagOpen() { 3106 return getRuleContexts(TdTagOpenContext.class); 3107 } 3108 public TdTagOpenContext tdTagOpen(int i) { 3109 return getRuleContext(TdTagOpenContext.class,i); 3110 } 3111 public List<ThTagOpenContext> thTagOpen() { 3112 return getRuleContexts(ThTagOpenContext.class); 3113 } 3114 public ThTagOpenContext thTagOpen(int i) { 3115 return getRuleContext(ThTagOpenContext.class,i); 3116 } 3117 public List<BodyTagOpenContext> bodyTagOpen() { 3118 return getRuleContexts(BodyTagOpenContext.class); 3119 } 3120 public BodyTagOpenContext bodyTagOpen(int i) { 3121 return getRuleContext(BodyTagOpenContext.class,i); 3122 } 3123 public List<ColgroupTagOpenContext> colgroupTagOpen() { 3124 return getRuleContexts(ColgroupTagOpenContext.class); 3125 } 3126 public ColgroupTagOpenContext colgroupTagOpen(int i) { 3127 return getRuleContext(ColgroupTagOpenContext.class,i); 3128 } 3129 public List<DdTagOpenContext> ddTagOpen() { 3130 return getRuleContexts(DdTagOpenContext.class); 3131 } 3132 public DdTagOpenContext ddTagOpen(int i) { 3133 return getRuleContext(DdTagOpenContext.class,i); 3134 } 3135 public List<DtTagOpenContext> dtTagOpen() { 3136 return getRuleContexts(DtTagOpenContext.class); 3137 } 3138 public DtTagOpenContext dtTagOpen(int i) { 3139 return getRuleContext(DtTagOpenContext.class,i); 3140 } 3141 public List<HeadTagOpenContext> headTagOpen() { 3142 return getRuleContexts(HeadTagOpenContext.class); 3143 } 3144 public HeadTagOpenContext headTagOpen(int i) { 3145 return getRuleContext(HeadTagOpenContext.class,i); 3146 } 3147 public List<HtmlTagOpenContext> htmlTagOpen() { 3148 return getRuleContexts(HtmlTagOpenContext.class); 3149 } 3150 public HtmlTagOpenContext htmlTagOpen(int i) { 3151 return getRuleContext(HtmlTagOpenContext.class,i); 3152 } 3153 public List<OptionTagOpenContext> optionTagOpen() { 3154 return getRuleContexts(OptionTagOpenContext.class); 3155 } 3156 public OptionTagOpenContext optionTagOpen(int i) { 3157 return getRuleContext(OptionTagOpenContext.class,i); 3158 } 3159 public List<TbodyTagOpenContext> tbodyTagOpen() { 3160 return getRuleContexts(TbodyTagOpenContext.class); 3161 } 3162 public TbodyTagOpenContext tbodyTagOpen(int i) { 3163 return getRuleContext(TbodyTagOpenContext.class,i); 3164 } 3165 public List<TheadTagOpenContext> theadTagOpen() { 3166 return getRuleContexts(TheadTagOpenContext.class); 3167 } 3168 public TheadTagOpenContext theadTagOpen(int i) { 3169 return getRuleContext(TheadTagOpenContext.class,i); 3170 } 3171 public List<TfootTagOpenContext> tfootTagOpen() { 3172 return getRuleContexts(TfootTagOpenContext.class); 3173 } 3174 public TfootTagOpenContext tfootTagOpen(int i) { 3175 return getRuleContext(TfootTagOpenContext.class,i); 3176 } 3177 public List<HtmlCommentContext> htmlComment() { 3178 return getRuleContexts(HtmlCommentContext.class); 3179 } 3180 public HtmlCommentContext htmlComment(int i) { 3181 return getRuleContext(HtmlCommentContext.class,i); 3182 } 3183 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3184 public TerminalNode CDATA(int i) { 3185 return getToken(JavadocParser.CDATA, i); 3186 } 3187 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3188 public TerminalNode NEWLINE(int i) { 3189 return getToken(JavadocParser.NEWLINE, i); 3190 } 3191 public List<TextContext> text() { 3192 return getRuleContexts(TextContext.class); 3193 } 3194 public TextContext text(int i) { 3195 return getRuleContext(TextContext.class,i); 3196 } 3197 public List<JavadocInlineTagContext> javadocInlineTag() { 3198 return getRuleContexts(JavadocInlineTagContext.class); 3199 } 3200 public JavadocInlineTagContext javadocInlineTag(int i) { 3201 return getRuleContext(JavadocInlineTagContext.class,i); 3202 } 3203 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3204 public TerminalNode LEADING_ASTERISK(int i) { 3205 return getToken(JavadocParser.LEADING_ASTERISK, i); 3206 } 3207 public TrContext(ParserRuleContext parent, int invokingState) { 3208 super(parent, invokingState); 3209 } 3210 @Override public int getRuleIndex() { return RULE_tr; } 3211 @Override 3212 public void enterRule(ParseTreeListener listener) { 3213 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTr(this); 3214 } 3215 @Override 3216 public void exitRule(ParseTreeListener listener) { 3217 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTr(this); 3218 } 3219 @Override 3220 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3221 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTr(this); 3222 else return visitor.visitChildren(this); 3223 } 3224 } 3225 3226 public final TrContext tr() throws RecognitionException { 3227 TrContext _localctx = new TrContext(_ctx, getState()); 3228 enterRule(_localctx, 28, RULE_tr); 3229 try { 3230 int _alt; 3231 enterOuterAlt(_localctx, 1); 3232 { 3233 setState(468); 3234 trTagOpen(); 3235 setState(508); 3236 _errHandler.sync(this); 3237 _alt = getInterpreter().adaptivePredict(_input,31,_ctx); 3238 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3239 if ( _alt==1 ) { 3240 { 3241 setState(506); 3242 switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) { 3243 case 1: 3244 { 3245 setState(469); 3246 htmlTag(); 3247 } 3248 break; 3249 case 2: 3250 { 3251 setState(470); 3252 singletonTag(); 3253 } 3254 break; 3255 case 3: 3256 { 3257 setState(471); 3258 paragraph(); 3259 } 3260 break; 3261 case 4: 3262 { 3263 setState(472); 3264 li(); 3265 } 3266 break; 3267 case 5: 3268 { 3269 setState(473); 3270 td(); 3271 } 3272 break; 3273 case 6: 3274 { 3275 setState(474); 3276 th(); 3277 } 3278 break; 3279 case 7: 3280 { 3281 setState(475); 3282 body(); 3283 } 3284 break; 3285 case 8: 3286 { 3287 setState(476); 3288 colgroup(); 3289 } 3290 break; 3291 case 9: 3292 { 3293 setState(477); 3294 dd(); 3295 } 3296 break; 3297 case 10: 3298 { 3299 setState(478); 3300 dt(); 3301 } 3302 break; 3303 case 11: 3304 { 3305 setState(479); 3306 head(); 3307 } 3308 break; 3309 case 12: 3310 { 3311 setState(480); 3312 html(); 3313 } 3314 break; 3315 case 13: 3316 { 3317 setState(481); 3318 option(); 3319 } 3320 break; 3321 case 14: 3322 { 3323 setState(482); 3324 tbody(); 3325 } 3326 break; 3327 case 15: 3328 { 3329 setState(483); 3330 thead(); 3331 } 3332 break; 3333 case 16: 3334 { 3335 setState(484); 3336 tfoot(); 3337 } 3338 break; 3339 case 17: 3340 { 3341 setState(485); 3342 pTagOpen(); 3343 } 3344 break; 3345 case 18: 3346 { 3347 setState(486); 3348 liTagOpen(); 3349 } 3350 break; 3351 case 19: 3352 { 3353 setState(487); 3354 tdTagOpen(); 3355 } 3356 break; 3357 case 20: 3358 { 3359 setState(488); 3360 thTagOpen(); 3361 } 3362 break; 3363 case 21: 3364 { 3365 setState(489); 3366 bodyTagOpen(); 3367 } 3368 break; 3369 case 22: 3370 { 3371 setState(490); 3372 colgroupTagOpen(); 3373 } 3374 break; 3375 case 23: 3376 { 3377 setState(491); 3378 ddTagOpen(); 3379 } 3380 break; 3381 case 24: 3382 { 3383 setState(492); 3384 dtTagOpen(); 3385 } 3386 break; 3387 case 25: 3388 { 3389 setState(493); 3390 headTagOpen(); 3391 } 3392 break; 3393 case 26: 3394 { 3395 setState(494); 3396 htmlTagOpen(); 3397 } 3398 break; 3399 case 27: 3400 { 3401 setState(495); 3402 optionTagOpen(); 3403 } 3404 break; 3405 case 28: 3406 { 3407 setState(496); 3408 tbodyTagOpen(); 3409 } 3410 break; 3411 case 29: 3412 { 3413 setState(497); 3414 theadTagOpen(); 3415 } 3416 break; 3417 case 30: 3418 { 3419 setState(498); 3420 tfootTagOpen(); 3421 } 3422 break; 3423 case 31: 3424 { 3425 { 3426 setState(499); 3427 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 3428 setState(500); 3429 match(LEADING_ASTERISK); 3430 } 3431 } 3432 break; 3433 case 32: 3434 { 3435 setState(501); 3436 htmlComment(); 3437 } 3438 break; 3439 case 33: 3440 { 3441 setState(502); 3442 match(CDATA); 3443 } 3444 break; 3445 case 34: 3446 { 3447 setState(503); 3448 match(NEWLINE); 3449 } 3450 break; 3451 case 35: 3452 { 3453 setState(504); 3454 text(); 3455 } 3456 break; 3457 case 36: 3458 { 3459 setState(505); 3460 javadocInlineTag(); 3461 } 3462 break; 3463 } 3464 } 3465 } 3466 setState(510); 3467 _errHandler.sync(this); 3468 _alt = getInterpreter().adaptivePredict(_input,31,_ctx); 3469 } 3470 setState(511); 3471 trTagClose(); 3472 } 3473 } 3474 catch (RecognitionException re) { 3475 _localctx.exception = re; 3476 _errHandler.reportError(this, re); 3477 _errHandler.recover(this, re); 3478 } 3479 finally { 3480 exitRule(); 3481 } 3482 return _localctx; 3483 } 3484 3485 public static class TdTagOpenContext extends ParserRuleContext { 3486 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 3487 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3488 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 3489 public List<AttributeContext> attribute() { 3490 return getRuleContexts(AttributeContext.class); 3491 } 3492 public AttributeContext attribute(int i) { 3493 return getRuleContext(AttributeContext.class,i); 3494 } 3495 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3496 public TerminalNode NEWLINE(int i) { 3497 return getToken(JavadocParser.NEWLINE, i); 3498 } 3499 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3500 public TerminalNode LEADING_ASTERISK(int i) { 3501 return getToken(JavadocParser.LEADING_ASTERISK, i); 3502 } 3503 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3504 public TerminalNode WS(int i) { 3505 return getToken(JavadocParser.WS, i); 3506 } 3507 public TdTagOpenContext(ParserRuleContext parent, int invokingState) { 3508 super(parent, invokingState); 3509 } 3510 @Override public int getRuleIndex() { return RULE_tdTagOpen; } 3511 @Override 3512 public void enterRule(ParseTreeListener listener) { 3513 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagOpen(this); 3514 } 3515 @Override 3516 public void exitRule(ParseTreeListener listener) { 3517 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagOpen(this); 3518 } 3519 @Override 3520 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3521 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagOpen(this); 3522 else return visitor.visitChildren(this); 3523 } 3524 } 3525 3526 public final TdTagOpenContext tdTagOpen() throws RecognitionException { 3527 TdTagOpenContext _localctx = new TdTagOpenContext(_ctx, getState()); 3528 enterRule(_localctx, 30, RULE_tdTagOpen); 3529 int _la; 3530 try { 3531 enterOuterAlt(_localctx, 1); 3532 { 3533 setState(513); 3534 match(OPEN); 3535 setState(514); 3536 match(TD_HTML_TAG_NAME); 3537 setState(521); 3538 _errHandler.sync(this); 3539 _la = _input.LA(1); 3540 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 3541 { 3542 setState(519); 3543 switch (_input.LA(1)) { 3544 case HTML_TAG_NAME: 3545 { 3546 setState(515); 3547 attribute(); 3548 } 3549 break; 3550 case NEWLINE: 3551 { 3552 setState(516); 3553 match(NEWLINE); 3554 } 3555 break; 3556 case LEADING_ASTERISK: 3557 { 3558 setState(517); 3559 match(LEADING_ASTERISK); 3560 } 3561 break; 3562 case WS: 3563 { 3564 setState(518); 3565 match(WS); 3566 } 3567 break; 3568 default: 3569 throw new NoViableAltException(this); 3570 } 3571 } 3572 setState(523); 3573 _errHandler.sync(this); 3574 _la = _input.LA(1); 3575 } 3576 setState(524); 3577 match(CLOSE); 3578 } 3579 } 3580 catch (RecognitionException re) { 3581 _localctx.exception = re; 3582 _errHandler.reportError(this, re); 3583 _errHandler.recover(this, re); 3584 } 3585 finally { 3586 exitRule(); 3587 } 3588 return _localctx; 3589 } 3590 3591 public static class TdTagCloseContext extends ParserRuleContext { 3592 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 3593 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 3594 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3595 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 3596 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3597 public TerminalNode NEWLINE(int i) { 3598 return getToken(JavadocParser.NEWLINE, i); 3599 } 3600 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3601 public TerminalNode LEADING_ASTERISK(int i) { 3602 return getToken(JavadocParser.LEADING_ASTERISK, i); 3603 } 3604 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3605 public TerminalNode WS(int i) { 3606 return getToken(JavadocParser.WS, i); 3607 } 3608 public TdTagCloseContext(ParserRuleContext parent, int invokingState) { 3609 super(parent, invokingState); 3610 } 3611 @Override public int getRuleIndex() { return RULE_tdTagClose; } 3612 @Override 3613 public void enterRule(ParseTreeListener listener) { 3614 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagClose(this); 3615 } 3616 @Override 3617 public void exitRule(ParseTreeListener listener) { 3618 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagClose(this); 3619 } 3620 @Override 3621 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3622 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagClose(this); 3623 else return visitor.visitChildren(this); 3624 } 3625 } 3626 3627 public final TdTagCloseContext tdTagClose() throws RecognitionException { 3628 TdTagCloseContext _localctx = new TdTagCloseContext(_ctx, getState()); 3629 enterRule(_localctx, 32, RULE_tdTagClose); 3630 int _la; 3631 try { 3632 enterOuterAlt(_localctx, 1); 3633 { 3634 setState(526); 3635 match(OPEN); 3636 setState(527); 3637 match(SLASH); 3638 setState(528); 3639 match(TD_HTML_TAG_NAME); 3640 setState(532); 3641 _errHandler.sync(this); 3642 _la = _input.LA(1); 3643 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3644 { 3645 { 3646 setState(529); 3647 _la = _input.LA(1); 3648 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3649 _errHandler.recoverInline(this); 3650 } else { 3651 consume(); 3652 } 3653 } 3654 } 3655 setState(534); 3656 _errHandler.sync(this); 3657 _la = _input.LA(1); 3658 } 3659 setState(535); 3660 match(CLOSE); 3661 } 3662 } 3663 catch (RecognitionException re) { 3664 _localctx.exception = re; 3665 _errHandler.reportError(this, re); 3666 _errHandler.recover(this, re); 3667 } 3668 finally { 3669 exitRule(); 3670 } 3671 return _localctx; 3672 } 3673 3674 public static class TdContext extends ParserRuleContext { 3675 public List<TdTagOpenContext> tdTagOpen() { 3676 return getRuleContexts(TdTagOpenContext.class); 3677 } 3678 public TdTagOpenContext tdTagOpen(int i) { 3679 return getRuleContext(TdTagOpenContext.class,i); 3680 } 3681 public TdTagCloseContext tdTagClose() { 3682 return getRuleContext(TdTagCloseContext.class,0); 3683 } 3684 public List<HtmlTagContext> htmlTag() { 3685 return getRuleContexts(HtmlTagContext.class); 3686 } 3687 public HtmlTagContext htmlTag(int i) { 3688 return getRuleContext(HtmlTagContext.class,i); 3689 } 3690 public List<SingletonTagContext> singletonTag() { 3691 return getRuleContexts(SingletonTagContext.class); 3692 } 3693 public SingletonTagContext singletonTag(int i) { 3694 return getRuleContext(SingletonTagContext.class,i); 3695 } 3696 public List<ParagraphContext> paragraph() { 3697 return getRuleContexts(ParagraphContext.class); 3698 } 3699 public ParagraphContext paragraph(int i) { 3700 return getRuleContext(ParagraphContext.class,i); 3701 } 3702 public List<LiContext> li() { 3703 return getRuleContexts(LiContext.class); 3704 } 3705 public LiContext li(int i) { 3706 return getRuleContext(LiContext.class,i); 3707 } 3708 public List<TrContext> tr() { 3709 return getRuleContexts(TrContext.class); 3710 } 3711 public TrContext tr(int i) { 3712 return getRuleContext(TrContext.class,i); 3713 } 3714 public List<ThContext> th() { 3715 return getRuleContexts(ThContext.class); 3716 } 3717 public ThContext th(int i) { 3718 return getRuleContext(ThContext.class,i); 3719 } 3720 public List<BodyContext> body() { 3721 return getRuleContexts(BodyContext.class); 3722 } 3723 public BodyContext body(int i) { 3724 return getRuleContext(BodyContext.class,i); 3725 } 3726 public List<ColgroupContext> colgroup() { 3727 return getRuleContexts(ColgroupContext.class); 3728 } 3729 public ColgroupContext colgroup(int i) { 3730 return getRuleContext(ColgroupContext.class,i); 3731 } 3732 public List<DdContext> dd() { 3733 return getRuleContexts(DdContext.class); 3734 } 3735 public DdContext dd(int i) { 3736 return getRuleContext(DdContext.class,i); 3737 } 3738 public List<DtContext> dt() { 3739 return getRuleContexts(DtContext.class); 3740 } 3741 public DtContext dt(int i) { 3742 return getRuleContext(DtContext.class,i); 3743 } 3744 public List<HeadContext> head() { 3745 return getRuleContexts(HeadContext.class); 3746 } 3747 public HeadContext head(int i) { 3748 return getRuleContext(HeadContext.class,i); 3749 } 3750 public List<HtmlContext> html() { 3751 return getRuleContexts(HtmlContext.class); 3752 } 3753 public HtmlContext html(int i) { 3754 return getRuleContext(HtmlContext.class,i); 3755 } 3756 public List<OptionContext> option() { 3757 return getRuleContexts(OptionContext.class); 3758 } 3759 public OptionContext option(int i) { 3760 return getRuleContext(OptionContext.class,i); 3761 } 3762 public List<TbodyContext> tbody() { 3763 return getRuleContexts(TbodyContext.class); 3764 } 3765 public TbodyContext tbody(int i) { 3766 return getRuleContext(TbodyContext.class,i); 3767 } 3768 public List<TheadContext> thead() { 3769 return getRuleContexts(TheadContext.class); 3770 } 3771 public TheadContext thead(int i) { 3772 return getRuleContext(TheadContext.class,i); 3773 } 3774 public List<TfootContext> tfoot() { 3775 return getRuleContexts(TfootContext.class); 3776 } 3777 public TfootContext tfoot(int i) { 3778 return getRuleContext(TfootContext.class,i); 3779 } 3780 public List<PTagOpenContext> pTagOpen() { 3781 return getRuleContexts(PTagOpenContext.class); 3782 } 3783 public PTagOpenContext pTagOpen(int i) { 3784 return getRuleContext(PTagOpenContext.class,i); 3785 } 3786 public List<LiTagOpenContext> liTagOpen() { 3787 return getRuleContexts(LiTagOpenContext.class); 3788 } 3789 public LiTagOpenContext liTagOpen(int i) { 3790 return getRuleContext(LiTagOpenContext.class,i); 3791 } 3792 public List<ThTagOpenContext> thTagOpen() { 3793 return getRuleContexts(ThTagOpenContext.class); 3794 } 3795 public ThTagOpenContext thTagOpen(int i) { 3796 return getRuleContext(ThTagOpenContext.class,i); 3797 } 3798 public List<BodyTagOpenContext> bodyTagOpen() { 3799 return getRuleContexts(BodyTagOpenContext.class); 3800 } 3801 public BodyTagOpenContext bodyTagOpen(int i) { 3802 return getRuleContext(BodyTagOpenContext.class,i); 3803 } 3804 public List<ColgroupTagOpenContext> colgroupTagOpen() { 3805 return getRuleContexts(ColgroupTagOpenContext.class); 3806 } 3807 public ColgroupTagOpenContext colgroupTagOpen(int i) { 3808 return getRuleContext(ColgroupTagOpenContext.class,i); 3809 } 3810 public List<DdTagOpenContext> ddTagOpen() { 3811 return getRuleContexts(DdTagOpenContext.class); 3812 } 3813 public DdTagOpenContext ddTagOpen(int i) { 3814 return getRuleContext(DdTagOpenContext.class,i); 3815 } 3816 public List<DtTagOpenContext> dtTagOpen() { 3817 return getRuleContexts(DtTagOpenContext.class); 3818 } 3819 public DtTagOpenContext dtTagOpen(int i) { 3820 return getRuleContext(DtTagOpenContext.class,i); 3821 } 3822 public List<HeadTagOpenContext> headTagOpen() { 3823 return getRuleContexts(HeadTagOpenContext.class); 3824 } 3825 public HeadTagOpenContext headTagOpen(int i) { 3826 return getRuleContext(HeadTagOpenContext.class,i); 3827 } 3828 public List<HtmlTagOpenContext> htmlTagOpen() { 3829 return getRuleContexts(HtmlTagOpenContext.class); 3830 } 3831 public HtmlTagOpenContext htmlTagOpen(int i) { 3832 return getRuleContext(HtmlTagOpenContext.class,i); 3833 } 3834 public List<OptionTagOpenContext> optionTagOpen() { 3835 return getRuleContexts(OptionTagOpenContext.class); 3836 } 3837 public OptionTagOpenContext optionTagOpen(int i) { 3838 return getRuleContext(OptionTagOpenContext.class,i); 3839 } 3840 public List<TbodyTagOpenContext> tbodyTagOpen() { 3841 return getRuleContexts(TbodyTagOpenContext.class); 3842 } 3843 public TbodyTagOpenContext tbodyTagOpen(int i) { 3844 return getRuleContext(TbodyTagOpenContext.class,i); 3845 } 3846 public List<TheadTagOpenContext> theadTagOpen() { 3847 return getRuleContexts(TheadTagOpenContext.class); 3848 } 3849 public TheadTagOpenContext theadTagOpen(int i) { 3850 return getRuleContext(TheadTagOpenContext.class,i); 3851 } 3852 public List<TfootTagOpenContext> tfootTagOpen() { 3853 return getRuleContexts(TfootTagOpenContext.class); 3854 } 3855 public TfootTagOpenContext tfootTagOpen(int i) { 3856 return getRuleContext(TfootTagOpenContext.class,i); 3857 } 3858 public List<HtmlCommentContext> htmlComment() { 3859 return getRuleContexts(HtmlCommentContext.class); 3860 } 3861 public HtmlCommentContext htmlComment(int i) { 3862 return getRuleContext(HtmlCommentContext.class,i); 3863 } 3864 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3865 public TerminalNode CDATA(int i) { 3866 return getToken(JavadocParser.CDATA, i); 3867 } 3868 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3869 public TerminalNode NEWLINE(int i) { 3870 return getToken(JavadocParser.NEWLINE, i); 3871 } 3872 public List<TextContext> text() { 3873 return getRuleContexts(TextContext.class); 3874 } 3875 public TextContext text(int i) { 3876 return getRuleContext(TextContext.class,i); 3877 } 3878 public List<JavadocInlineTagContext> javadocInlineTag() { 3879 return getRuleContexts(JavadocInlineTagContext.class); 3880 } 3881 public JavadocInlineTagContext javadocInlineTag(int i) { 3882 return getRuleContext(JavadocInlineTagContext.class,i); 3883 } 3884 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3885 public TerminalNode LEADING_ASTERISK(int i) { 3886 return getToken(JavadocParser.LEADING_ASTERISK, i); 3887 } 3888 public TdContext(ParserRuleContext parent, int invokingState) { 3889 super(parent, invokingState); 3890 } 3891 @Override public int getRuleIndex() { return RULE_td; } 3892 @Override 3893 public void enterRule(ParseTreeListener listener) { 3894 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTd(this); 3895 } 3896 @Override 3897 public void exitRule(ParseTreeListener listener) { 3898 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTd(this); 3899 } 3900 @Override 3901 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3902 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTd(this); 3903 else return visitor.visitChildren(this); 3904 } 3905 } 3906 3907 public final TdContext td() throws RecognitionException { 3908 TdContext _localctx = new TdContext(_ctx, getState()); 3909 enterRule(_localctx, 34, RULE_td); 3910 try { 3911 int _alt; 3912 enterOuterAlt(_localctx, 1); 3913 { 3914 setState(537); 3915 tdTagOpen(); 3916 setState(577); 3917 _errHandler.sync(this); 3918 _alt = getInterpreter().adaptivePredict(_input,36,_ctx); 3919 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3920 if ( _alt==1 ) { 3921 { 3922 setState(575); 3923 switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { 3924 case 1: 3925 { 3926 setState(538); 3927 htmlTag(); 3928 } 3929 break; 3930 case 2: 3931 { 3932 setState(539); 3933 singletonTag(); 3934 } 3935 break; 3936 case 3: 3937 { 3938 setState(540); 3939 paragraph(); 3940 } 3941 break; 3942 case 4: 3943 { 3944 setState(541); 3945 li(); 3946 } 3947 break; 3948 case 5: 3949 { 3950 setState(542); 3951 tr(); 3952 } 3953 break; 3954 case 6: 3955 { 3956 setState(543); 3957 th(); 3958 } 3959 break; 3960 case 7: 3961 { 3962 setState(544); 3963 body(); 3964 } 3965 break; 3966 case 8: 3967 { 3968 setState(545); 3969 colgroup(); 3970 } 3971 break; 3972 case 9: 3973 { 3974 setState(546); 3975 dd(); 3976 } 3977 break; 3978 case 10: 3979 { 3980 setState(547); 3981 dt(); 3982 } 3983 break; 3984 case 11: 3985 { 3986 setState(548); 3987 head(); 3988 } 3989 break; 3990 case 12: 3991 { 3992 setState(549); 3993 html(); 3994 } 3995 break; 3996 case 13: 3997 { 3998 setState(550); 3999 option(); 4000 } 4001 break; 4002 case 14: 4003 { 4004 setState(551); 4005 tbody(); 4006 } 4007 break; 4008 case 15: 4009 { 4010 setState(552); 4011 thead(); 4012 } 4013 break; 4014 case 16: 4015 { 4016 setState(553); 4017 tfoot(); 4018 } 4019 break; 4020 case 17: 4021 { 4022 setState(554); 4023 pTagOpen(); 4024 } 4025 break; 4026 case 18: 4027 { 4028 setState(555); 4029 liTagOpen(); 4030 } 4031 break; 4032 case 19: 4033 { 4034 setState(556); 4035 tdTagOpen(); 4036 } 4037 break; 4038 case 20: 4039 { 4040 setState(557); 4041 thTagOpen(); 4042 } 4043 break; 4044 case 21: 4045 { 4046 setState(558); 4047 bodyTagOpen(); 4048 } 4049 break; 4050 case 22: 4051 { 4052 setState(559); 4053 colgroupTagOpen(); 4054 } 4055 break; 4056 case 23: 4057 { 4058 setState(560); 4059 ddTagOpen(); 4060 } 4061 break; 4062 case 24: 4063 { 4064 setState(561); 4065 dtTagOpen(); 4066 } 4067 break; 4068 case 25: 4069 { 4070 setState(562); 4071 headTagOpen(); 4072 } 4073 break; 4074 case 26: 4075 { 4076 setState(563); 4077 htmlTagOpen(); 4078 } 4079 break; 4080 case 27: 4081 { 4082 setState(564); 4083 optionTagOpen(); 4084 } 4085 break; 4086 case 28: 4087 { 4088 setState(565); 4089 tbodyTagOpen(); 4090 } 4091 break; 4092 case 29: 4093 { 4094 setState(566); 4095 theadTagOpen(); 4096 } 4097 break; 4098 case 30: 4099 { 4100 setState(567); 4101 tfootTagOpen(); 4102 } 4103 break; 4104 case 31: 4105 { 4106 { 4107 setState(568); 4108 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4109 setState(569); 4110 match(LEADING_ASTERISK); 4111 } 4112 } 4113 break; 4114 case 32: 4115 { 4116 setState(570); 4117 htmlComment(); 4118 } 4119 break; 4120 case 33: 4121 { 4122 setState(571); 4123 match(CDATA); 4124 } 4125 break; 4126 case 34: 4127 { 4128 setState(572); 4129 match(NEWLINE); 4130 } 4131 break; 4132 case 35: 4133 { 4134 setState(573); 4135 text(); 4136 } 4137 break; 4138 case 36: 4139 { 4140 setState(574); 4141 javadocInlineTag(); 4142 } 4143 break; 4144 } 4145 } 4146 } 4147 setState(579); 4148 _errHandler.sync(this); 4149 _alt = getInterpreter().adaptivePredict(_input,36,_ctx); 4150 } 4151 setState(580); 4152 tdTagClose(); 4153 } 4154 } 4155 catch (RecognitionException re) { 4156 _localctx.exception = re; 4157 _errHandler.reportError(this, re); 4158 _errHandler.recover(this, re); 4159 } 4160 finally { 4161 exitRule(); 4162 } 4163 return _localctx; 4164 } 4165 4166 public static class ThTagOpenContext extends ParserRuleContext { 4167 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4168 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4169 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4170 public List<AttributeContext> attribute() { 4171 return getRuleContexts(AttributeContext.class); 4172 } 4173 public AttributeContext attribute(int i) { 4174 return getRuleContext(AttributeContext.class,i); 4175 } 4176 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4177 public TerminalNode NEWLINE(int i) { 4178 return getToken(JavadocParser.NEWLINE, i); 4179 } 4180 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4181 public TerminalNode LEADING_ASTERISK(int i) { 4182 return getToken(JavadocParser.LEADING_ASTERISK, i); 4183 } 4184 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4185 public TerminalNode WS(int i) { 4186 return getToken(JavadocParser.WS, i); 4187 } 4188 public ThTagOpenContext(ParserRuleContext parent, int invokingState) { 4189 super(parent, invokingState); 4190 } 4191 @Override public int getRuleIndex() { return RULE_thTagOpen; } 4192 @Override 4193 public void enterRule(ParseTreeListener listener) { 4194 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagOpen(this); 4195 } 4196 @Override 4197 public void exitRule(ParseTreeListener listener) { 4198 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagOpen(this); 4199 } 4200 @Override 4201 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4202 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagOpen(this); 4203 else return visitor.visitChildren(this); 4204 } 4205 } 4206 4207 public final ThTagOpenContext thTagOpen() throws RecognitionException { 4208 ThTagOpenContext _localctx = new ThTagOpenContext(_ctx, getState()); 4209 enterRule(_localctx, 36, RULE_thTagOpen); 4210 int _la; 4211 try { 4212 enterOuterAlt(_localctx, 1); 4213 { 4214 setState(582); 4215 match(OPEN); 4216 setState(583); 4217 match(TH_HTML_TAG_NAME); 4218 setState(590); 4219 _errHandler.sync(this); 4220 _la = _input.LA(1); 4221 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4222 { 4223 setState(588); 4224 switch (_input.LA(1)) { 4225 case HTML_TAG_NAME: 4226 { 4227 setState(584); 4228 attribute(); 4229 } 4230 break; 4231 case NEWLINE: 4232 { 4233 setState(585); 4234 match(NEWLINE); 4235 } 4236 break; 4237 case LEADING_ASTERISK: 4238 { 4239 setState(586); 4240 match(LEADING_ASTERISK); 4241 } 4242 break; 4243 case WS: 4244 { 4245 setState(587); 4246 match(WS); 4247 } 4248 break; 4249 default: 4250 throw new NoViableAltException(this); 4251 } 4252 } 4253 setState(592); 4254 _errHandler.sync(this); 4255 _la = _input.LA(1); 4256 } 4257 setState(593); 4258 match(CLOSE); 4259 } 4260 } 4261 catch (RecognitionException re) { 4262 _localctx.exception = re; 4263 _errHandler.reportError(this, re); 4264 _errHandler.recover(this, re); 4265 } 4266 finally { 4267 exitRule(); 4268 } 4269 return _localctx; 4270 } 4271 4272 public static class ThTagCloseContext extends ParserRuleContext { 4273 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4274 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4275 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4276 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4277 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4278 public TerminalNode NEWLINE(int i) { 4279 return getToken(JavadocParser.NEWLINE, i); 4280 } 4281 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4282 public TerminalNode LEADING_ASTERISK(int i) { 4283 return getToken(JavadocParser.LEADING_ASTERISK, i); 4284 } 4285 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4286 public TerminalNode WS(int i) { 4287 return getToken(JavadocParser.WS, i); 4288 } 4289 public ThTagCloseContext(ParserRuleContext parent, int invokingState) { 4290 super(parent, invokingState); 4291 } 4292 @Override public int getRuleIndex() { return RULE_thTagClose; } 4293 @Override 4294 public void enterRule(ParseTreeListener listener) { 4295 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagClose(this); 4296 } 4297 @Override 4298 public void exitRule(ParseTreeListener listener) { 4299 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagClose(this); 4300 } 4301 @Override 4302 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4303 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagClose(this); 4304 else return visitor.visitChildren(this); 4305 } 4306 } 4307 4308 public final ThTagCloseContext thTagClose() throws RecognitionException { 4309 ThTagCloseContext _localctx = new ThTagCloseContext(_ctx, getState()); 4310 enterRule(_localctx, 38, RULE_thTagClose); 4311 int _la; 4312 try { 4313 enterOuterAlt(_localctx, 1); 4314 { 4315 setState(595); 4316 match(OPEN); 4317 setState(596); 4318 match(SLASH); 4319 setState(597); 4320 match(TH_HTML_TAG_NAME); 4321 setState(601); 4322 _errHandler.sync(this); 4323 _la = _input.LA(1); 4324 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 4325 { 4326 { 4327 setState(598); 4328 _la = _input.LA(1); 4329 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 4330 _errHandler.recoverInline(this); 4331 } else { 4332 consume(); 4333 } 4334 } 4335 } 4336 setState(603); 4337 _errHandler.sync(this); 4338 _la = _input.LA(1); 4339 } 4340 setState(604); 4341 match(CLOSE); 4342 } 4343 } 4344 catch (RecognitionException re) { 4345 _localctx.exception = re; 4346 _errHandler.reportError(this, re); 4347 _errHandler.recover(this, re); 4348 } 4349 finally { 4350 exitRule(); 4351 } 4352 return _localctx; 4353 } 4354 4355 public static class ThContext extends ParserRuleContext { 4356 public ThTagOpenContext thTagOpen() { 4357 return getRuleContext(ThTagOpenContext.class,0); 4358 } 4359 public ThTagCloseContext thTagClose() { 4360 return getRuleContext(ThTagCloseContext.class,0); 4361 } 4362 public List<HtmlTagContext> htmlTag() { 4363 return getRuleContexts(HtmlTagContext.class); 4364 } 4365 public HtmlTagContext htmlTag(int i) { 4366 return getRuleContext(HtmlTagContext.class,i); 4367 } 4368 public List<SingletonTagContext> singletonTag() { 4369 return getRuleContexts(SingletonTagContext.class); 4370 } 4371 public SingletonTagContext singletonTag(int i) { 4372 return getRuleContext(SingletonTagContext.class,i); 4373 } 4374 public List<ParagraphContext> paragraph() { 4375 return getRuleContexts(ParagraphContext.class); 4376 } 4377 public ParagraphContext paragraph(int i) { 4378 return getRuleContext(ParagraphContext.class,i); 4379 } 4380 public List<LiContext> li() { 4381 return getRuleContexts(LiContext.class); 4382 } 4383 public LiContext li(int i) { 4384 return getRuleContext(LiContext.class,i); 4385 } 4386 public List<TrContext> tr() { 4387 return getRuleContexts(TrContext.class); 4388 } 4389 public TrContext tr(int i) { 4390 return getRuleContext(TrContext.class,i); 4391 } 4392 public List<TdContext> td() { 4393 return getRuleContexts(TdContext.class); 4394 } 4395 public TdContext td(int i) { 4396 return getRuleContext(TdContext.class,i); 4397 } 4398 public List<BodyContext> body() { 4399 return getRuleContexts(BodyContext.class); 4400 } 4401 public BodyContext body(int i) { 4402 return getRuleContext(BodyContext.class,i); 4403 } 4404 public List<ColgroupContext> colgroup() { 4405 return getRuleContexts(ColgroupContext.class); 4406 } 4407 public ColgroupContext colgroup(int i) { 4408 return getRuleContext(ColgroupContext.class,i); 4409 } 4410 public List<DdContext> dd() { 4411 return getRuleContexts(DdContext.class); 4412 } 4413 public DdContext dd(int i) { 4414 return getRuleContext(DdContext.class,i); 4415 } 4416 public List<DtContext> dt() { 4417 return getRuleContexts(DtContext.class); 4418 } 4419 public DtContext dt(int i) { 4420 return getRuleContext(DtContext.class,i); 4421 } 4422 public List<HeadContext> head() { 4423 return getRuleContexts(HeadContext.class); 4424 } 4425 public HeadContext head(int i) { 4426 return getRuleContext(HeadContext.class,i); 4427 } 4428 public List<HtmlContext> html() { 4429 return getRuleContexts(HtmlContext.class); 4430 } 4431 public HtmlContext html(int i) { 4432 return getRuleContext(HtmlContext.class,i); 4433 } 4434 public List<OptionContext> option() { 4435 return getRuleContexts(OptionContext.class); 4436 } 4437 public OptionContext option(int i) { 4438 return getRuleContext(OptionContext.class,i); 4439 } 4440 public List<TbodyContext> tbody() { 4441 return getRuleContexts(TbodyContext.class); 4442 } 4443 public TbodyContext tbody(int i) { 4444 return getRuleContext(TbodyContext.class,i); 4445 } 4446 public List<TheadContext> thead() { 4447 return getRuleContexts(TheadContext.class); 4448 } 4449 public TheadContext thead(int i) { 4450 return getRuleContext(TheadContext.class,i); 4451 } 4452 public List<TfootContext> tfoot() { 4453 return getRuleContexts(TfootContext.class); 4454 } 4455 public TfootContext tfoot(int i) { 4456 return getRuleContext(TfootContext.class,i); 4457 } 4458 public List<PTagOpenContext> pTagOpen() { 4459 return getRuleContexts(PTagOpenContext.class); 4460 } 4461 public PTagOpenContext pTagOpen(int i) { 4462 return getRuleContext(PTagOpenContext.class,i); 4463 } 4464 public List<LiTagOpenContext> liTagOpen() { 4465 return getRuleContexts(LiTagOpenContext.class); 4466 } 4467 public LiTagOpenContext liTagOpen(int i) { 4468 return getRuleContext(LiTagOpenContext.class,i); 4469 } 4470 public List<TrTagOpenContext> trTagOpen() { 4471 return getRuleContexts(TrTagOpenContext.class); 4472 } 4473 public TrTagOpenContext trTagOpen(int i) { 4474 return getRuleContext(TrTagOpenContext.class,i); 4475 } 4476 public List<TdTagOpenContext> tdTagOpen() { 4477 return getRuleContexts(TdTagOpenContext.class); 4478 } 4479 public TdTagOpenContext tdTagOpen(int i) { 4480 return getRuleContext(TdTagOpenContext.class,i); 4481 } 4482 public List<BodyTagOpenContext> bodyTagOpen() { 4483 return getRuleContexts(BodyTagOpenContext.class); 4484 } 4485 public BodyTagOpenContext bodyTagOpen(int i) { 4486 return getRuleContext(BodyTagOpenContext.class,i); 4487 } 4488 public List<ColgroupTagOpenContext> colgroupTagOpen() { 4489 return getRuleContexts(ColgroupTagOpenContext.class); 4490 } 4491 public ColgroupTagOpenContext colgroupTagOpen(int i) { 4492 return getRuleContext(ColgroupTagOpenContext.class,i); 4493 } 4494 public List<DdTagOpenContext> ddTagOpen() { 4495 return getRuleContexts(DdTagOpenContext.class); 4496 } 4497 public DdTagOpenContext ddTagOpen(int i) { 4498 return getRuleContext(DdTagOpenContext.class,i); 4499 } 4500 public List<DtTagOpenContext> dtTagOpen() { 4501 return getRuleContexts(DtTagOpenContext.class); 4502 } 4503 public DtTagOpenContext dtTagOpen(int i) { 4504 return getRuleContext(DtTagOpenContext.class,i); 4505 } 4506 public List<HeadTagOpenContext> headTagOpen() { 4507 return getRuleContexts(HeadTagOpenContext.class); 4508 } 4509 public HeadTagOpenContext headTagOpen(int i) { 4510 return getRuleContext(HeadTagOpenContext.class,i); 4511 } 4512 public List<HtmlTagOpenContext> htmlTagOpen() { 4513 return getRuleContexts(HtmlTagOpenContext.class); 4514 } 4515 public HtmlTagOpenContext htmlTagOpen(int i) { 4516 return getRuleContext(HtmlTagOpenContext.class,i); 4517 } 4518 public List<OptionTagOpenContext> optionTagOpen() { 4519 return getRuleContexts(OptionTagOpenContext.class); 4520 } 4521 public OptionTagOpenContext optionTagOpen(int i) { 4522 return getRuleContext(OptionTagOpenContext.class,i); 4523 } 4524 public List<TbodyTagOpenContext> tbodyTagOpen() { 4525 return getRuleContexts(TbodyTagOpenContext.class); 4526 } 4527 public TbodyTagOpenContext tbodyTagOpen(int i) { 4528 return getRuleContext(TbodyTagOpenContext.class,i); 4529 } 4530 public List<TheadTagOpenContext> theadTagOpen() { 4531 return getRuleContexts(TheadTagOpenContext.class); 4532 } 4533 public TheadTagOpenContext theadTagOpen(int i) { 4534 return getRuleContext(TheadTagOpenContext.class,i); 4535 } 4536 public List<TfootTagOpenContext> tfootTagOpen() { 4537 return getRuleContexts(TfootTagOpenContext.class); 4538 } 4539 public TfootTagOpenContext tfootTagOpen(int i) { 4540 return getRuleContext(TfootTagOpenContext.class,i); 4541 } 4542 public List<HtmlCommentContext> htmlComment() { 4543 return getRuleContexts(HtmlCommentContext.class); 4544 } 4545 public HtmlCommentContext htmlComment(int i) { 4546 return getRuleContext(HtmlCommentContext.class,i); 4547 } 4548 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 4549 public TerminalNode CDATA(int i) { 4550 return getToken(JavadocParser.CDATA, i); 4551 } 4552 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4553 public TerminalNode NEWLINE(int i) { 4554 return getToken(JavadocParser.NEWLINE, i); 4555 } 4556 public List<TextContext> text() { 4557 return getRuleContexts(TextContext.class); 4558 } 4559 public TextContext text(int i) { 4560 return getRuleContext(TextContext.class,i); 4561 } 4562 public List<JavadocInlineTagContext> javadocInlineTag() { 4563 return getRuleContexts(JavadocInlineTagContext.class); 4564 } 4565 public JavadocInlineTagContext javadocInlineTag(int i) { 4566 return getRuleContext(JavadocInlineTagContext.class,i); 4567 } 4568 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4569 public TerminalNode LEADING_ASTERISK(int i) { 4570 return getToken(JavadocParser.LEADING_ASTERISK, i); 4571 } 4572 public ThContext(ParserRuleContext parent, int invokingState) { 4573 super(parent, invokingState); 4574 } 4575 @Override public int getRuleIndex() { return RULE_th; } 4576 @Override 4577 public void enterRule(ParseTreeListener listener) { 4578 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTh(this); 4579 } 4580 @Override 4581 public void exitRule(ParseTreeListener listener) { 4582 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTh(this); 4583 } 4584 @Override 4585 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4586 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTh(this); 4587 else return visitor.visitChildren(this); 4588 } 4589 } 4590 4591 public final ThContext th() throws RecognitionException { 4592 ThContext _localctx = new ThContext(_ctx, getState()); 4593 enterRule(_localctx, 40, RULE_th); 4594 try { 4595 int _alt; 4596 enterOuterAlt(_localctx, 1); 4597 { 4598 setState(606); 4599 thTagOpen(); 4600 setState(646); 4601 _errHandler.sync(this); 4602 _alt = getInterpreter().adaptivePredict(_input,41,_ctx); 4603 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 4604 if ( _alt==1 ) { 4605 { 4606 setState(644); 4607 switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { 4608 case 1: 4609 { 4610 setState(607); 4611 htmlTag(); 4612 } 4613 break; 4614 case 2: 4615 { 4616 setState(608); 4617 singletonTag(); 4618 } 4619 break; 4620 case 3: 4621 { 4622 setState(609); 4623 paragraph(); 4624 } 4625 break; 4626 case 4: 4627 { 4628 setState(610); 4629 li(); 4630 } 4631 break; 4632 case 5: 4633 { 4634 setState(611); 4635 tr(); 4636 } 4637 break; 4638 case 6: 4639 { 4640 setState(612); 4641 td(); 4642 } 4643 break; 4644 case 7: 4645 { 4646 setState(613); 4647 body(); 4648 } 4649 break; 4650 case 8: 4651 { 4652 setState(614); 4653 colgroup(); 4654 } 4655 break; 4656 case 9: 4657 { 4658 setState(615); 4659 dd(); 4660 } 4661 break; 4662 case 10: 4663 { 4664 setState(616); 4665 dt(); 4666 } 4667 break; 4668 case 11: 4669 { 4670 setState(617); 4671 head(); 4672 } 4673 break; 4674 case 12: 4675 { 4676 setState(618); 4677 html(); 4678 } 4679 break; 4680 case 13: 4681 { 4682 setState(619); 4683 option(); 4684 } 4685 break; 4686 case 14: 4687 { 4688 setState(620); 4689 tbody(); 4690 } 4691 break; 4692 case 15: 4693 { 4694 setState(621); 4695 thead(); 4696 } 4697 break; 4698 case 16: 4699 { 4700 setState(622); 4701 tfoot(); 4702 } 4703 break; 4704 case 17: 4705 { 4706 setState(623); 4707 pTagOpen(); 4708 } 4709 break; 4710 case 18: 4711 { 4712 setState(624); 4713 liTagOpen(); 4714 } 4715 break; 4716 case 19: 4717 { 4718 setState(625); 4719 trTagOpen(); 4720 } 4721 break; 4722 case 20: 4723 { 4724 setState(626); 4725 tdTagOpen(); 4726 } 4727 break; 4728 case 21: 4729 { 4730 setState(627); 4731 bodyTagOpen(); 4732 } 4733 break; 4734 case 22: 4735 { 4736 setState(628); 4737 colgroupTagOpen(); 4738 } 4739 break; 4740 case 23: 4741 { 4742 setState(629); 4743 ddTagOpen(); 4744 } 4745 break; 4746 case 24: 4747 { 4748 setState(630); 4749 dtTagOpen(); 4750 } 4751 break; 4752 case 25: 4753 { 4754 setState(631); 4755 headTagOpen(); 4756 } 4757 break; 4758 case 26: 4759 { 4760 setState(632); 4761 htmlTagOpen(); 4762 } 4763 break; 4764 case 27: 4765 { 4766 setState(633); 4767 optionTagOpen(); 4768 } 4769 break; 4770 case 28: 4771 { 4772 setState(634); 4773 tbodyTagOpen(); 4774 } 4775 break; 4776 case 29: 4777 { 4778 setState(635); 4779 theadTagOpen(); 4780 } 4781 break; 4782 case 30: 4783 { 4784 setState(636); 4785 tfootTagOpen(); 4786 } 4787 break; 4788 case 31: 4789 { 4790 { 4791 setState(637); 4792 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4793 setState(638); 4794 match(LEADING_ASTERISK); 4795 } 4796 } 4797 break; 4798 case 32: 4799 { 4800 setState(639); 4801 htmlComment(); 4802 } 4803 break; 4804 case 33: 4805 { 4806 setState(640); 4807 match(CDATA); 4808 } 4809 break; 4810 case 34: 4811 { 4812 setState(641); 4813 match(NEWLINE); 4814 } 4815 break; 4816 case 35: 4817 { 4818 setState(642); 4819 text(); 4820 } 4821 break; 4822 case 36: 4823 { 4824 setState(643); 4825 javadocInlineTag(); 4826 } 4827 break; 4828 } 4829 } 4830 } 4831 setState(648); 4832 _errHandler.sync(this); 4833 _alt = getInterpreter().adaptivePredict(_input,41,_ctx); 4834 } 4835 setState(649); 4836 thTagClose(); 4837 } 4838 } 4839 catch (RecognitionException re) { 4840 _localctx.exception = re; 4841 _errHandler.reportError(this, re); 4842 _errHandler.recover(this, re); 4843 } 4844 finally { 4845 exitRule(); 4846 } 4847 return _localctx; 4848 } 4849 4850 public static class BodyTagOpenContext extends ParserRuleContext { 4851 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4852 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 4853 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4854 public List<AttributeContext> attribute() { 4855 return getRuleContexts(AttributeContext.class); 4856 } 4857 public AttributeContext attribute(int i) { 4858 return getRuleContext(AttributeContext.class,i); 4859 } 4860 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4861 public TerminalNode NEWLINE(int i) { 4862 return getToken(JavadocParser.NEWLINE, i); 4863 } 4864 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4865 public TerminalNode LEADING_ASTERISK(int i) { 4866 return getToken(JavadocParser.LEADING_ASTERISK, i); 4867 } 4868 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4869 public TerminalNode WS(int i) { 4870 return getToken(JavadocParser.WS, i); 4871 } 4872 public BodyTagOpenContext(ParserRuleContext parent, int invokingState) { 4873 super(parent, invokingState); 4874 } 4875 @Override public int getRuleIndex() { return RULE_bodyTagOpen; } 4876 @Override 4877 public void enterRule(ParseTreeListener listener) { 4878 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagOpen(this); 4879 } 4880 @Override 4881 public void exitRule(ParseTreeListener listener) { 4882 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagOpen(this); 4883 } 4884 @Override 4885 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4886 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagOpen(this); 4887 else return visitor.visitChildren(this); 4888 } 4889 } 4890 4891 public final BodyTagOpenContext bodyTagOpen() throws RecognitionException { 4892 BodyTagOpenContext _localctx = new BodyTagOpenContext(_ctx, getState()); 4893 enterRule(_localctx, 42, RULE_bodyTagOpen); 4894 int _la; 4895 try { 4896 enterOuterAlt(_localctx, 1); 4897 { 4898 setState(651); 4899 match(OPEN); 4900 setState(652); 4901 match(BODY_HTML_TAG_NAME); 4902 setState(659); 4903 _errHandler.sync(this); 4904 _la = _input.LA(1); 4905 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4906 { 4907 setState(657); 4908 switch (_input.LA(1)) { 4909 case HTML_TAG_NAME: 4910 { 4911 setState(653); 4912 attribute(); 4913 } 4914 break; 4915 case NEWLINE: 4916 { 4917 setState(654); 4918 match(NEWLINE); 4919 } 4920 break; 4921 case LEADING_ASTERISK: 4922 { 4923 setState(655); 4924 match(LEADING_ASTERISK); 4925 } 4926 break; 4927 case WS: 4928 { 4929 setState(656); 4930 match(WS); 4931 } 4932 break; 4933 default: 4934 throw new NoViableAltException(this); 4935 } 4936 } 4937 setState(661); 4938 _errHandler.sync(this); 4939 _la = _input.LA(1); 4940 } 4941 setState(662); 4942 match(CLOSE); 4943 } 4944 } 4945 catch (RecognitionException re) { 4946 _localctx.exception = re; 4947 _errHandler.reportError(this, re); 4948 _errHandler.recover(this, re); 4949 } 4950 finally { 4951 exitRule(); 4952 } 4953 return _localctx; 4954 } 4955 4956 public static class BodyTagCloseContext extends ParserRuleContext { 4957 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4958 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4959 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 4960 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4961 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4962 public TerminalNode NEWLINE(int i) { 4963 return getToken(JavadocParser.NEWLINE, i); 4964 } 4965 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4966 public TerminalNode LEADING_ASTERISK(int i) { 4967 return getToken(JavadocParser.LEADING_ASTERISK, i); 4968 } 4969 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4970 public TerminalNode WS(int i) { 4971 return getToken(JavadocParser.WS, i); 4972 } 4973 public BodyTagCloseContext(ParserRuleContext parent, int invokingState) { 4974 super(parent, invokingState); 4975 } 4976 @Override public int getRuleIndex() { return RULE_bodyTagClose; } 4977 @Override 4978 public void enterRule(ParseTreeListener listener) { 4979 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagClose(this); 4980 } 4981 @Override 4982 public void exitRule(ParseTreeListener listener) { 4983 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagClose(this); 4984 } 4985 @Override 4986 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4987 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagClose(this); 4988 else return visitor.visitChildren(this); 4989 } 4990 } 4991 4992 public final BodyTagCloseContext bodyTagClose() throws RecognitionException { 4993 BodyTagCloseContext _localctx = new BodyTagCloseContext(_ctx, getState()); 4994 enterRule(_localctx, 44, RULE_bodyTagClose); 4995 int _la; 4996 try { 4997 enterOuterAlt(_localctx, 1); 4998 { 4999 setState(664); 5000 match(OPEN); 5001 setState(665); 5002 match(SLASH); 5003 setState(666); 5004 match(BODY_HTML_TAG_NAME); 5005 setState(670); 5006 _errHandler.sync(this); 5007 _la = _input.LA(1); 5008 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5009 { 5010 { 5011 setState(667); 5012 _la = _input.LA(1); 5013 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5014 _errHandler.recoverInline(this); 5015 } else { 5016 consume(); 5017 } 5018 } 5019 } 5020 setState(672); 5021 _errHandler.sync(this); 5022 _la = _input.LA(1); 5023 } 5024 setState(673); 5025 match(CLOSE); 5026 } 5027 } 5028 catch (RecognitionException re) { 5029 _localctx.exception = re; 5030 _errHandler.reportError(this, re); 5031 _errHandler.recover(this, re); 5032 } 5033 finally { 5034 exitRule(); 5035 } 5036 return _localctx; 5037 } 5038 5039 public static class BodyContext extends ParserRuleContext { 5040 public BodyTagOpenContext bodyTagOpen() { 5041 return getRuleContext(BodyTagOpenContext.class,0); 5042 } 5043 public BodyTagCloseContext bodyTagClose() { 5044 return getRuleContext(BodyTagCloseContext.class,0); 5045 } 5046 public List<HtmlTagContext> htmlTag() { 5047 return getRuleContexts(HtmlTagContext.class); 5048 } 5049 public HtmlTagContext htmlTag(int i) { 5050 return getRuleContext(HtmlTagContext.class,i); 5051 } 5052 public List<SingletonTagContext> singletonTag() { 5053 return getRuleContexts(SingletonTagContext.class); 5054 } 5055 public SingletonTagContext singletonTag(int i) { 5056 return getRuleContext(SingletonTagContext.class,i); 5057 } 5058 public List<ParagraphContext> paragraph() { 5059 return getRuleContexts(ParagraphContext.class); 5060 } 5061 public ParagraphContext paragraph(int i) { 5062 return getRuleContext(ParagraphContext.class,i); 5063 } 5064 public List<LiContext> li() { 5065 return getRuleContexts(LiContext.class); 5066 } 5067 public LiContext li(int i) { 5068 return getRuleContext(LiContext.class,i); 5069 } 5070 public List<TrContext> tr() { 5071 return getRuleContexts(TrContext.class); 5072 } 5073 public TrContext tr(int i) { 5074 return getRuleContext(TrContext.class,i); 5075 } 5076 public List<TdContext> td() { 5077 return getRuleContexts(TdContext.class); 5078 } 5079 public TdContext td(int i) { 5080 return getRuleContext(TdContext.class,i); 5081 } 5082 public List<ThContext> th() { 5083 return getRuleContexts(ThContext.class); 5084 } 5085 public ThContext th(int i) { 5086 return getRuleContext(ThContext.class,i); 5087 } 5088 public List<ColgroupContext> colgroup() { 5089 return getRuleContexts(ColgroupContext.class); 5090 } 5091 public ColgroupContext colgroup(int i) { 5092 return getRuleContext(ColgroupContext.class,i); 5093 } 5094 public List<DdContext> dd() { 5095 return getRuleContexts(DdContext.class); 5096 } 5097 public DdContext dd(int i) { 5098 return getRuleContext(DdContext.class,i); 5099 } 5100 public List<DtContext> dt() { 5101 return getRuleContexts(DtContext.class); 5102 } 5103 public DtContext dt(int i) { 5104 return getRuleContext(DtContext.class,i); 5105 } 5106 public List<HeadContext> head() { 5107 return getRuleContexts(HeadContext.class); 5108 } 5109 public HeadContext head(int i) { 5110 return getRuleContext(HeadContext.class,i); 5111 } 5112 public List<HtmlContext> html() { 5113 return getRuleContexts(HtmlContext.class); 5114 } 5115 public HtmlContext html(int i) { 5116 return getRuleContext(HtmlContext.class,i); 5117 } 5118 public List<OptionContext> option() { 5119 return getRuleContexts(OptionContext.class); 5120 } 5121 public OptionContext option(int i) { 5122 return getRuleContext(OptionContext.class,i); 5123 } 5124 public List<TbodyContext> tbody() { 5125 return getRuleContexts(TbodyContext.class); 5126 } 5127 public TbodyContext tbody(int i) { 5128 return getRuleContext(TbodyContext.class,i); 5129 } 5130 public List<TheadContext> thead() { 5131 return getRuleContexts(TheadContext.class); 5132 } 5133 public TheadContext thead(int i) { 5134 return getRuleContext(TheadContext.class,i); 5135 } 5136 public List<TfootContext> tfoot() { 5137 return getRuleContexts(TfootContext.class); 5138 } 5139 public TfootContext tfoot(int i) { 5140 return getRuleContext(TfootContext.class,i); 5141 } 5142 public List<PTagOpenContext> pTagOpen() { 5143 return getRuleContexts(PTagOpenContext.class); 5144 } 5145 public PTagOpenContext pTagOpen(int i) { 5146 return getRuleContext(PTagOpenContext.class,i); 5147 } 5148 public List<LiTagOpenContext> liTagOpen() { 5149 return getRuleContexts(LiTagOpenContext.class); 5150 } 5151 public LiTagOpenContext liTagOpen(int i) { 5152 return getRuleContext(LiTagOpenContext.class,i); 5153 } 5154 public List<TrTagOpenContext> trTagOpen() { 5155 return getRuleContexts(TrTagOpenContext.class); 5156 } 5157 public TrTagOpenContext trTagOpen(int i) { 5158 return getRuleContext(TrTagOpenContext.class,i); 5159 } 5160 public List<TdTagOpenContext> tdTagOpen() { 5161 return getRuleContexts(TdTagOpenContext.class); 5162 } 5163 public TdTagOpenContext tdTagOpen(int i) { 5164 return getRuleContext(TdTagOpenContext.class,i); 5165 } 5166 public List<ThTagOpenContext> thTagOpen() { 5167 return getRuleContexts(ThTagOpenContext.class); 5168 } 5169 public ThTagOpenContext thTagOpen(int i) { 5170 return getRuleContext(ThTagOpenContext.class,i); 5171 } 5172 public List<ColgroupTagOpenContext> colgroupTagOpen() { 5173 return getRuleContexts(ColgroupTagOpenContext.class); 5174 } 5175 public ColgroupTagOpenContext colgroupTagOpen(int i) { 5176 return getRuleContext(ColgroupTagOpenContext.class,i); 5177 } 5178 public List<DdTagOpenContext> ddTagOpen() { 5179 return getRuleContexts(DdTagOpenContext.class); 5180 } 5181 public DdTagOpenContext ddTagOpen(int i) { 5182 return getRuleContext(DdTagOpenContext.class,i); 5183 } 5184 public List<DtTagOpenContext> dtTagOpen() { 5185 return getRuleContexts(DtTagOpenContext.class); 5186 } 5187 public DtTagOpenContext dtTagOpen(int i) { 5188 return getRuleContext(DtTagOpenContext.class,i); 5189 } 5190 public List<HeadTagOpenContext> headTagOpen() { 5191 return getRuleContexts(HeadTagOpenContext.class); 5192 } 5193 public HeadTagOpenContext headTagOpen(int i) { 5194 return getRuleContext(HeadTagOpenContext.class,i); 5195 } 5196 public List<HtmlTagOpenContext> htmlTagOpen() { 5197 return getRuleContexts(HtmlTagOpenContext.class); 5198 } 5199 public HtmlTagOpenContext htmlTagOpen(int i) { 5200 return getRuleContext(HtmlTagOpenContext.class,i); 5201 } 5202 public List<OptionTagOpenContext> optionTagOpen() { 5203 return getRuleContexts(OptionTagOpenContext.class); 5204 } 5205 public OptionTagOpenContext optionTagOpen(int i) { 5206 return getRuleContext(OptionTagOpenContext.class,i); 5207 } 5208 public List<TbodyTagOpenContext> tbodyTagOpen() { 5209 return getRuleContexts(TbodyTagOpenContext.class); 5210 } 5211 public TbodyTagOpenContext tbodyTagOpen(int i) { 5212 return getRuleContext(TbodyTagOpenContext.class,i); 5213 } 5214 public List<TheadTagOpenContext> theadTagOpen() { 5215 return getRuleContexts(TheadTagOpenContext.class); 5216 } 5217 public TheadTagOpenContext theadTagOpen(int i) { 5218 return getRuleContext(TheadTagOpenContext.class,i); 5219 } 5220 public List<TfootTagOpenContext> tfootTagOpen() { 5221 return getRuleContexts(TfootTagOpenContext.class); 5222 } 5223 public TfootTagOpenContext tfootTagOpen(int i) { 5224 return getRuleContext(TfootTagOpenContext.class,i); 5225 } 5226 public List<HtmlCommentContext> htmlComment() { 5227 return getRuleContexts(HtmlCommentContext.class); 5228 } 5229 public HtmlCommentContext htmlComment(int i) { 5230 return getRuleContext(HtmlCommentContext.class,i); 5231 } 5232 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5233 public TerminalNode CDATA(int i) { 5234 return getToken(JavadocParser.CDATA, i); 5235 } 5236 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5237 public TerminalNode NEWLINE(int i) { 5238 return getToken(JavadocParser.NEWLINE, i); 5239 } 5240 public List<TextContext> text() { 5241 return getRuleContexts(TextContext.class); 5242 } 5243 public TextContext text(int i) { 5244 return getRuleContext(TextContext.class,i); 5245 } 5246 public List<JavadocInlineTagContext> javadocInlineTag() { 5247 return getRuleContexts(JavadocInlineTagContext.class); 5248 } 5249 public JavadocInlineTagContext javadocInlineTag(int i) { 5250 return getRuleContext(JavadocInlineTagContext.class,i); 5251 } 5252 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5253 public TerminalNode LEADING_ASTERISK(int i) { 5254 return getToken(JavadocParser.LEADING_ASTERISK, i); 5255 } 5256 public BodyContext(ParserRuleContext parent, int invokingState) { 5257 super(parent, invokingState); 5258 } 5259 @Override public int getRuleIndex() { return RULE_body; } 5260 @Override 5261 public void enterRule(ParseTreeListener listener) { 5262 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBody(this); 5263 } 5264 @Override 5265 public void exitRule(ParseTreeListener listener) { 5266 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBody(this); 5267 } 5268 @Override 5269 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5270 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBody(this); 5271 else return visitor.visitChildren(this); 5272 } 5273 } 5274 5275 public final BodyContext body() throws RecognitionException { 5276 BodyContext _localctx = new BodyContext(_ctx, getState()); 5277 enterRule(_localctx, 46, RULE_body); 5278 try { 5279 int _alt; 5280 enterOuterAlt(_localctx, 1); 5281 { 5282 setState(675); 5283 bodyTagOpen(); 5284 setState(715); 5285 _errHandler.sync(this); 5286 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5287 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5288 if ( _alt==1 ) { 5289 { 5290 setState(713); 5291 switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { 5292 case 1: 5293 { 5294 setState(676); 5295 htmlTag(); 5296 } 5297 break; 5298 case 2: 5299 { 5300 setState(677); 5301 singletonTag(); 5302 } 5303 break; 5304 case 3: 5305 { 5306 setState(678); 5307 paragraph(); 5308 } 5309 break; 5310 case 4: 5311 { 5312 setState(679); 5313 li(); 5314 } 5315 break; 5316 case 5: 5317 { 5318 setState(680); 5319 tr(); 5320 } 5321 break; 5322 case 6: 5323 { 5324 setState(681); 5325 td(); 5326 } 5327 break; 5328 case 7: 5329 { 5330 setState(682); 5331 th(); 5332 } 5333 break; 5334 case 8: 5335 { 5336 setState(683); 5337 colgroup(); 5338 } 5339 break; 5340 case 9: 5341 { 5342 setState(684); 5343 dd(); 5344 } 5345 break; 5346 case 10: 5347 { 5348 setState(685); 5349 dt(); 5350 } 5351 break; 5352 case 11: 5353 { 5354 setState(686); 5355 head(); 5356 } 5357 break; 5358 case 12: 5359 { 5360 setState(687); 5361 html(); 5362 } 5363 break; 5364 case 13: 5365 { 5366 setState(688); 5367 option(); 5368 } 5369 break; 5370 case 14: 5371 { 5372 setState(689); 5373 tbody(); 5374 } 5375 break; 5376 case 15: 5377 { 5378 setState(690); 5379 thead(); 5380 } 5381 break; 5382 case 16: 5383 { 5384 setState(691); 5385 tfoot(); 5386 } 5387 break; 5388 case 17: 5389 { 5390 setState(692); 5391 pTagOpen(); 5392 } 5393 break; 5394 case 18: 5395 { 5396 setState(693); 5397 liTagOpen(); 5398 } 5399 break; 5400 case 19: 5401 { 5402 setState(694); 5403 trTagOpen(); 5404 } 5405 break; 5406 case 20: 5407 { 5408 setState(695); 5409 tdTagOpen(); 5410 } 5411 break; 5412 case 21: 5413 { 5414 setState(696); 5415 thTagOpen(); 5416 } 5417 break; 5418 case 22: 5419 { 5420 setState(697); 5421 colgroupTagOpen(); 5422 } 5423 break; 5424 case 23: 5425 { 5426 setState(698); 5427 ddTagOpen(); 5428 } 5429 break; 5430 case 24: 5431 { 5432 setState(699); 5433 dtTagOpen(); 5434 } 5435 break; 5436 case 25: 5437 { 5438 setState(700); 5439 headTagOpen(); 5440 } 5441 break; 5442 case 26: 5443 { 5444 setState(701); 5445 htmlTagOpen(); 5446 } 5447 break; 5448 case 27: 5449 { 5450 setState(702); 5451 optionTagOpen(); 5452 } 5453 break; 5454 case 28: 5455 { 5456 setState(703); 5457 tbodyTagOpen(); 5458 } 5459 break; 5460 case 29: 5461 { 5462 setState(704); 5463 theadTagOpen(); 5464 } 5465 break; 5466 case 30: 5467 { 5468 setState(705); 5469 tfootTagOpen(); 5470 } 5471 break; 5472 case 31: 5473 { 5474 { 5475 setState(706); 5476 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 5477 setState(707); 5478 match(LEADING_ASTERISK); 5479 } 5480 } 5481 break; 5482 case 32: 5483 { 5484 setState(708); 5485 htmlComment(); 5486 } 5487 break; 5488 case 33: 5489 { 5490 setState(709); 5491 match(CDATA); 5492 } 5493 break; 5494 case 34: 5495 { 5496 setState(710); 5497 match(NEWLINE); 5498 } 5499 break; 5500 case 35: 5501 { 5502 setState(711); 5503 text(); 5504 } 5505 break; 5506 case 36: 5507 { 5508 setState(712); 5509 javadocInlineTag(); 5510 } 5511 break; 5512 } 5513 } 5514 } 5515 setState(717); 5516 _errHandler.sync(this); 5517 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5518 } 5519 setState(718); 5520 bodyTagClose(); 5521 } 5522 } 5523 catch (RecognitionException re) { 5524 _localctx.exception = re; 5525 _errHandler.reportError(this, re); 5526 _errHandler.recover(this, re); 5527 } 5528 finally { 5529 exitRule(); 5530 } 5531 return _localctx; 5532 } 5533 5534 public static class ColgroupTagOpenContext extends ParserRuleContext { 5535 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5536 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5537 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5538 public List<AttributeContext> attribute() { 5539 return getRuleContexts(AttributeContext.class); 5540 } 5541 public AttributeContext attribute(int i) { 5542 return getRuleContext(AttributeContext.class,i); 5543 } 5544 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5545 public TerminalNode NEWLINE(int i) { 5546 return getToken(JavadocParser.NEWLINE, i); 5547 } 5548 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5549 public TerminalNode LEADING_ASTERISK(int i) { 5550 return getToken(JavadocParser.LEADING_ASTERISK, i); 5551 } 5552 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5553 public TerminalNode WS(int i) { 5554 return getToken(JavadocParser.WS, i); 5555 } 5556 public ColgroupTagOpenContext(ParserRuleContext parent, int invokingState) { 5557 super(parent, invokingState); 5558 } 5559 @Override public int getRuleIndex() { return RULE_colgroupTagOpen; } 5560 @Override 5561 public void enterRule(ParseTreeListener listener) { 5562 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagOpen(this); 5563 } 5564 @Override 5565 public void exitRule(ParseTreeListener listener) { 5566 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagOpen(this); 5567 } 5568 @Override 5569 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5570 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagOpen(this); 5571 else return visitor.visitChildren(this); 5572 } 5573 } 5574 5575 public final ColgroupTagOpenContext colgroupTagOpen() throws RecognitionException { 5576 ColgroupTagOpenContext _localctx = new ColgroupTagOpenContext(_ctx, getState()); 5577 enterRule(_localctx, 48, RULE_colgroupTagOpen); 5578 int _la; 5579 try { 5580 enterOuterAlt(_localctx, 1); 5581 { 5582 setState(720); 5583 match(OPEN); 5584 setState(721); 5585 match(COLGROUP_HTML_TAG_NAME); 5586 setState(728); 5587 _errHandler.sync(this); 5588 _la = _input.LA(1); 5589 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 5590 { 5591 setState(726); 5592 switch (_input.LA(1)) { 5593 case HTML_TAG_NAME: 5594 { 5595 setState(722); 5596 attribute(); 5597 } 5598 break; 5599 case NEWLINE: 5600 { 5601 setState(723); 5602 match(NEWLINE); 5603 } 5604 break; 5605 case LEADING_ASTERISK: 5606 { 5607 setState(724); 5608 match(LEADING_ASTERISK); 5609 } 5610 break; 5611 case WS: 5612 { 5613 setState(725); 5614 match(WS); 5615 } 5616 break; 5617 default: 5618 throw new NoViableAltException(this); 5619 } 5620 } 5621 setState(730); 5622 _errHandler.sync(this); 5623 _la = _input.LA(1); 5624 } 5625 setState(731); 5626 match(CLOSE); 5627 } 5628 } 5629 catch (RecognitionException re) { 5630 _localctx.exception = re; 5631 _errHandler.reportError(this, re); 5632 _errHandler.recover(this, re); 5633 } 5634 finally { 5635 exitRule(); 5636 } 5637 return _localctx; 5638 } 5639 5640 public static class ColgroupTagCloseContext extends ParserRuleContext { 5641 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5642 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 5643 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5644 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5645 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5646 public TerminalNode NEWLINE(int i) { 5647 return getToken(JavadocParser.NEWLINE, i); 5648 } 5649 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5650 public TerminalNode LEADING_ASTERISK(int i) { 5651 return getToken(JavadocParser.LEADING_ASTERISK, i); 5652 } 5653 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5654 public TerminalNode WS(int i) { 5655 return getToken(JavadocParser.WS, i); 5656 } 5657 public ColgroupTagCloseContext(ParserRuleContext parent, int invokingState) { 5658 super(parent, invokingState); 5659 } 5660 @Override public int getRuleIndex() { return RULE_colgroupTagClose; } 5661 @Override 5662 public void enterRule(ParseTreeListener listener) { 5663 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagClose(this); 5664 } 5665 @Override 5666 public void exitRule(ParseTreeListener listener) { 5667 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagClose(this); 5668 } 5669 @Override 5670 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5671 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagClose(this); 5672 else return visitor.visitChildren(this); 5673 } 5674 } 5675 5676 public final ColgroupTagCloseContext colgroupTagClose() throws RecognitionException { 5677 ColgroupTagCloseContext _localctx = new ColgroupTagCloseContext(_ctx, getState()); 5678 enterRule(_localctx, 50, RULE_colgroupTagClose); 5679 int _la; 5680 try { 5681 enterOuterAlt(_localctx, 1); 5682 { 5683 setState(733); 5684 match(OPEN); 5685 setState(734); 5686 match(SLASH); 5687 setState(735); 5688 match(COLGROUP_HTML_TAG_NAME); 5689 setState(739); 5690 _errHandler.sync(this); 5691 _la = _input.LA(1); 5692 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5693 { 5694 { 5695 setState(736); 5696 _la = _input.LA(1); 5697 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5698 _errHandler.recoverInline(this); 5699 } else { 5700 consume(); 5701 } 5702 } 5703 } 5704 setState(741); 5705 _errHandler.sync(this); 5706 _la = _input.LA(1); 5707 } 5708 setState(742); 5709 match(CLOSE); 5710 } 5711 } 5712 catch (RecognitionException re) { 5713 _localctx.exception = re; 5714 _errHandler.reportError(this, re); 5715 _errHandler.recover(this, re); 5716 } 5717 finally { 5718 exitRule(); 5719 } 5720 return _localctx; 5721 } 5722 5723 public static class ColgroupContext extends ParserRuleContext { 5724 public ColgroupTagOpenContext colgroupTagOpen() { 5725 return getRuleContext(ColgroupTagOpenContext.class,0); 5726 } 5727 public ColgroupTagCloseContext colgroupTagClose() { 5728 return getRuleContext(ColgroupTagCloseContext.class,0); 5729 } 5730 public List<HtmlTagContext> htmlTag() { 5731 return getRuleContexts(HtmlTagContext.class); 5732 } 5733 public HtmlTagContext htmlTag(int i) { 5734 return getRuleContext(HtmlTagContext.class,i); 5735 } 5736 public List<SingletonTagContext> singletonTag() { 5737 return getRuleContexts(SingletonTagContext.class); 5738 } 5739 public SingletonTagContext singletonTag(int i) { 5740 return getRuleContext(SingletonTagContext.class,i); 5741 } 5742 public List<ParagraphContext> paragraph() { 5743 return getRuleContexts(ParagraphContext.class); 5744 } 5745 public ParagraphContext paragraph(int i) { 5746 return getRuleContext(ParagraphContext.class,i); 5747 } 5748 public List<LiContext> li() { 5749 return getRuleContexts(LiContext.class); 5750 } 5751 public LiContext li(int i) { 5752 return getRuleContext(LiContext.class,i); 5753 } 5754 public List<TrContext> tr() { 5755 return getRuleContexts(TrContext.class); 5756 } 5757 public TrContext tr(int i) { 5758 return getRuleContext(TrContext.class,i); 5759 } 5760 public List<TdContext> td() { 5761 return getRuleContexts(TdContext.class); 5762 } 5763 public TdContext td(int i) { 5764 return getRuleContext(TdContext.class,i); 5765 } 5766 public List<ThContext> th() { 5767 return getRuleContexts(ThContext.class); 5768 } 5769 public ThContext th(int i) { 5770 return getRuleContext(ThContext.class,i); 5771 } 5772 public List<BodyContext> body() { 5773 return getRuleContexts(BodyContext.class); 5774 } 5775 public BodyContext body(int i) { 5776 return getRuleContext(BodyContext.class,i); 5777 } 5778 public List<DdContext> dd() { 5779 return getRuleContexts(DdContext.class); 5780 } 5781 public DdContext dd(int i) { 5782 return getRuleContext(DdContext.class,i); 5783 } 5784 public List<DtContext> dt() { 5785 return getRuleContexts(DtContext.class); 5786 } 5787 public DtContext dt(int i) { 5788 return getRuleContext(DtContext.class,i); 5789 } 5790 public List<HeadContext> head() { 5791 return getRuleContexts(HeadContext.class); 5792 } 5793 public HeadContext head(int i) { 5794 return getRuleContext(HeadContext.class,i); 5795 } 5796 public List<HtmlContext> html() { 5797 return getRuleContexts(HtmlContext.class); 5798 } 5799 public HtmlContext html(int i) { 5800 return getRuleContext(HtmlContext.class,i); 5801 } 5802 public List<OptionContext> option() { 5803 return getRuleContexts(OptionContext.class); 5804 } 5805 public OptionContext option(int i) { 5806 return getRuleContext(OptionContext.class,i); 5807 } 5808 public List<TbodyContext> tbody() { 5809 return getRuleContexts(TbodyContext.class); 5810 } 5811 public TbodyContext tbody(int i) { 5812 return getRuleContext(TbodyContext.class,i); 5813 } 5814 public List<TheadContext> thead() { 5815 return getRuleContexts(TheadContext.class); 5816 } 5817 public TheadContext thead(int i) { 5818 return getRuleContext(TheadContext.class,i); 5819 } 5820 public List<TfootContext> tfoot() { 5821 return getRuleContexts(TfootContext.class); 5822 } 5823 public TfootContext tfoot(int i) { 5824 return getRuleContext(TfootContext.class,i); 5825 } 5826 public List<PTagOpenContext> pTagOpen() { 5827 return getRuleContexts(PTagOpenContext.class); 5828 } 5829 public PTagOpenContext pTagOpen(int i) { 5830 return getRuleContext(PTagOpenContext.class,i); 5831 } 5832 public List<LiTagOpenContext> liTagOpen() { 5833 return getRuleContexts(LiTagOpenContext.class); 5834 } 5835 public LiTagOpenContext liTagOpen(int i) { 5836 return getRuleContext(LiTagOpenContext.class,i); 5837 } 5838 public List<TrTagOpenContext> trTagOpen() { 5839 return getRuleContexts(TrTagOpenContext.class); 5840 } 5841 public TrTagOpenContext trTagOpen(int i) { 5842 return getRuleContext(TrTagOpenContext.class,i); 5843 } 5844 public List<TdTagOpenContext> tdTagOpen() { 5845 return getRuleContexts(TdTagOpenContext.class); 5846 } 5847 public TdTagOpenContext tdTagOpen(int i) { 5848 return getRuleContext(TdTagOpenContext.class,i); 5849 } 5850 public List<ThTagOpenContext> thTagOpen() { 5851 return getRuleContexts(ThTagOpenContext.class); 5852 } 5853 public ThTagOpenContext thTagOpen(int i) { 5854 return getRuleContext(ThTagOpenContext.class,i); 5855 } 5856 public List<BodyTagOpenContext> bodyTagOpen() { 5857 return getRuleContexts(BodyTagOpenContext.class); 5858 } 5859 public BodyTagOpenContext bodyTagOpen(int i) { 5860 return getRuleContext(BodyTagOpenContext.class,i); 5861 } 5862 public List<DdTagOpenContext> ddTagOpen() { 5863 return getRuleContexts(DdTagOpenContext.class); 5864 } 5865 public DdTagOpenContext ddTagOpen(int i) { 5866 return getRuleContext(DdTagOpenContext.class,i); 5867 } 5868 public List<DtTagOpenContext> dtTagOpen() { 5869 return getRuleContexts(DtTagOpenContext.class); 5870 } 5871 public DtTagOpenContext dtTagOpen(int i) { 5872 return getRuleContext(DtTagOpenContext.class,i); 5873 } 5874 public List<HeadTagOpenContext> headTagOpen() { 5875 return getRuleContexts(HeadTagOpenContext.class); 5876 } 5877 public HeadTagOpenContext headTagOpen(int i) { 5878 return getRuleContext(HeadTagOpenContext.class,i); 5879 } 5880 public List<HtmlTagOpenContext> htmlTagOpen() { 5881 return getRuleContexts(HtmlTagOpenContext.class); 5882 } 5883 public HtmlTagOpenContext htmlTagOpen(int i) { 5884 return getRuleContext(HtmlTagOpenContext.class,i); 5885 } 5886 public List<OptionTagOpenContext> optionTagOpen() { 5887 return getRuleContexts(OptionTagOpenContext.class); 5888 } 5889 public OptionTagOpenContext optionTagOpen(int i) { 5890 return getRuleContext(OptionTagOpenContext.class,i); 5891 } 5892 public List<TbodyTagOpenContext> tbodyTagOpen() { 5893 return getRuleContexts(TbodyTagOpenContext.class); 5894 } 5895 public TbodyTagOpenContext tbodyTagOpen(int i) { 5896 return getRuleContext(TbodyTagOpenContext.class,i); 5897 } 5898 public List<TheadTagOpenContext> theadTagOpen() { 5899 return getRuleContexts(TheadTagOpenContext.class); 5900 } 5901 public TheadTagOpenContext theadTagOpen(int i) { 5902 return getRuleContext(TheadTagOpenContext.class,i); 5903 } 5904 public List<TfootTagOpenContext> tfootTagOpen() { 5905 return getRuleContexts(TfootTagOpenContext.class); 5906 } 5907 public TfootTagOpenContext tfootTagOpen(int i) { 5908 return getRuleContext(TfootTagOpenContext.class,i); 5909 } 5910 public List<HtmlCommentContext> htmlComment() { 5911 return getRuleContexts(HtmlCommentContext.class); 5912 } 5913 public HtmlCommentContext htmlComment(int i) { 5914 return getRuleContext(HtmlCommentContext.class,i); 5915 } 5916 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5917 public TerminalNode CDATA(int i) { 5918 return getToken(JavadocParser.CDATA, i); 5919 } 5920 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5921 public TerminalNode NEWLINE(int i) { 5922 return getToken(JavadocParser.NEWLINE, i); 5923 } 5924 public List<TextContext> text() { 5925 return getRuleContexts(TextContext.class); 5926 } 5927 public TextContext text(int i) { 5928 return getRuleContext(TextContext.class,i); 5929 } 5930 public List<JavadocInlineTagContext> javadocInlineTag() { 5931 return getRuleContexts(JavadocInlineTagContext.class); 5932 } 5933 public JavadocInlineTagContext javadocInlineTag(int i) { 5934 return getRuleContext(JavadocInlineTagContext.class,i); 5935 } 5936 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5937 public TerminalNode LEADING_ASTERISK(int i) { 5938 return getToken(JavadocParser.LEADING_ASTERISK, i); 5939 } 5940 public ColgroupContext(ParserRuleContext parent, int invokingState) { 5941 super(parent, invokingState); 5942 } 5943 @Override public int getRuleIndex() { return RULE_colgroup; } 5944 @Override 5945 public void enterRule(ParseTreeListener listener) { 5946 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroup(this); 5947 } 5948 @Override 5949 public void exitRule(ParseTreeListener listener) { 5950 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroup(this); 5951 } 5952 @Override 5953 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5954 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroup(this); 5955 else return visitor.visitChildren(this); 5956 } 5957 } 5958 5959 public final ColgroupContext colgroup() throws RecognitionException { 5960 ColgroupContext _localctx = new ColgroupContext(_ctx, getState()); 5961 enterRule(_localctx, 52, RULE_colgroup); 5962 try { 5963 int _alt; 5964 enterOuterAlt(_localctx, 1); 5965 { 5966 setState(744); 5967 colgroupTagOpen(); 5968 setState(784); 5969 _errHandler.sync(this); 5970 _alt = getInterpreter().adaptivePredict(_input,51,_ctx); 5971 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5972 if ( _alt==1 ) { 5973 { 5974 setState(782); 5975 switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { 5976 case 1: 5977 { 5978 setState(745); 5979 htmlTag(); 5980 } 5981 break; 5982 case 2: 5983 { 5984 setState(746); 5985 singletonTag(); 5986 } 5987 break; 5988 case 3: 5989 { 5990 setState(747); 5991 paragraph(); 5992 } 5993 break; 5994 case 4: 5995 { 5996 setState(748); 5997 li(); 5998 } 5999 break; 6000 case 5: 6001 { 6002 setState(749); 6003 tr(); 6004 } 6005 break; 6006 case 6: 6007 { 6008 setState(750); 6009 td(); 6010 } 6011 break; 6012 case 7: 6013 { 6014 setState(751); 6015 th(); 6016 } 6017 break; 6018 case 8: 6019 { 6020 setState(752); 6021 body(); 6022 } 6023 break; 6024 case 9: 6025 { 6026 setState(753); 6027 dd(); 6028 } 6029 break; 6030 case 10: 6031 { 6032 setState(754); 6033 dt(); 6034 } 6035 break; 6036 case 11: 6037 { 6038 setState(755); 6039 head(); 6040 } 6041 break; 6042 case 12: 6043 { 6044 setState(756); 6045 html(); 6046 } 6047 break; 6048 case 13: 6049 { 6050 setState(757); 6051 option(); 6052 } 6053 break; 6054 case 14: 6055 { 6056 setState(758); 6057 tbody(); 6058 } 6059 break; 6060 case 15: 6061 { 6062 setState(759); 6063 thead(); 6064 } 6065 break; 6066 case 16: 6067 { 6068 setState(760); 6069 tfoot(); 6070 } 6071 break; 6072 case 17: 6073 { 6074 setState(761); 6075 pTagOpen(); 6076 } 6077 break; 6078 case 18: 6079 { 6080 setState(762); 6081 liTagOpen(); 6082 } 6083 break; 6084 case 19: 6085 { 6086 setState(763); 6087 trTagOpen(); 6088 } 6089 break; 6090 case 20: 6091 { 6092 setState(764); 6093 tdTagOpen(); 6094 } 6095 break; 6096 case 21: 6097 { 6098 setState(765); 6099 thTagOpen(); 6100 } 6101 break; 6102 case 22: 6103 { 6104 setState(766); 6105 bodyTagOpen(); 6106 } 6107 break; 6108 case 23: 6109 { 6110 setState(767); 6111 ddTagOpen(); 6112 } 6113 break; 6114 case 24: 6115 { 6116 setState(768); 6117 dtTagOpen(); 6118 } 6119 break; 6120 case 25: 6121 { 6122 setState(769); 6123 headTagOpen(); 6124 } 6125 break; 6126 case 26: 6127 { 6128 setState(770); 6129 htmlTagOpen(); 6130 } 6131 break; 6132 case 27: 6133 { 6134 setState(771); 6135 optionTagOpen(); 6136 } 6137 break; 6138 case 28: 6139 { 6140 setState(772); 6141 tbodyTagOpen(); 6142 } 6143 break; 6144 case 29: 6145 { 6146 setState(773); 6147 theadTagOpen(); 6148 } 6149 break; 6150 case 30: 6151 { 6152 setState(774); 6153 tfootTagOpen(); 6154 } 6155 break; 6156 case 31: 6157 { 6158 { 6159 setState(775); 6160 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6161 setState(776); 6162 match(LEADING_ASTERISK); 6163 } 6164 } 6165 break; 6166 case 32: 6167 { 6168 setState(777); 6169 htmlComment(); 6170 } 6171 break; 6172 case 33: 6173 { 6174 setState(778); 6175 match(CDATA); 6176 } 6177 break; 6178 case 34: 6179 { 6180 setState(779); 6181 match(NEWLINE); 6182 } 6183 break; 6184 case 35: 6185 { 6186 setState(780); 6187 text(); 6188 } 6189 break; 6190 case 36: 6191 { 6192 setState(781); 6193 javadocInlineTag(); 6194 } 6195 break; 6196 } 6197 } 6198 } 6199 setState(786); 6200 _errHandler.sync(this); 6201 _alt = getInterpreter().adaptivePredict(_input,51,_ctx); 6202 } 6203 setState(787); 6204 colgroupTagClose(); 6205 } 6206 } 6207 catch (RecognitionException re) { 6208 _localctx.exception = re; 6209 _errHandler.reportError(this, re); 6210 _errHandler.recover(this, re); 6211 } 6212 finally { 6213 exitRule(); 6214 } 6215 return _localctx; 6216 } 6217 6218 public static class DdTagOpenContext extends ParserRuleContext { 6219 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6220 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6221 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6222 public List<AttributeContext> attribute() { 6223 return getRuleContexts(AttributeContext.class); 6224 } 6225 public AttributeContext attribute(int i) { 6226 return getRuleContext(AttributeContext.class,i); 6227 } 6228 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6229 public TerminalNode NEWLINE(int i) { 6230 return getToken(JavadocParser.NEWLINE, i); 6231 } 6232 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6233 public TerminalNode LEADING_ASTERISK(int i) { 6234 return getToken(JavadocParser.LEADING_ASTERISK, i); 6235 } 6236 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6237 public TerminalNode WS(int i) { 6238 return getToken(JavadocParser.WS, i); 6239 } 6240 public DdTagOpenContext(ParserRuleContext parent, int invokingState) { 6241 super(parent, invokingState); 6242 } 6243 @Override public int getRuleIndex() { return RULE_ddTagOpen; } 6244 @Override 6245 public void enterRule(ParseTreeListener listener) { 6246 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagOpen(this); 6247 } 6248 @Override 6249 public void exitRule(ParseTreeListener listener) { 6250 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagOpen(this); 6251 } 6252 @Override 6253 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6254 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagOpen(this); 6255 else return visitor.visitChildren(this); 6256 } 6257 } 6258 6259 public final DdTagOpenContext ddTagOpen() throws RecognitionException { 6260 DdTagOpenContext _localctx = new DdTagOpenContext(_ctx, getState()); 6261 enterRule(_localctx, 54, RULE_ddTagOpen); 6262 int _la; 6263 try { 6264 enterOuterAlt(_localctx, 1); 6265 { 6266 setState(789); 6267 match(OPEN); 6268 setState(790); 6269 match(DD_HTML_TAG_NAME); 6270 setState(797); 6271 _errHandler.sync(this); 6272 _la = _input.LA(1); 6273 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6274 { 6275 setState(795); 6276 switch (_input.LA(1)) { 6277 case HTML_TAG_NAME: 6278 { 6279 setState(791); 6280 attribute(); 6281 } 6282 break; 6283 case NEWLINE: 6284 { 6285 setState(792); 6286 match(NEWLINE); 6287 } 6288 break; 6289 case LEADING_ASTERISK: 6290 { 6291 setState(793); 6292 match(LEADING_ASTERISK); 6293 } 6294 break; 6295 case WS: 6296 { 6297 setState(794); 6298 match(WS); 6299 } 6300 break; 6301 default: 6302 throw new NoViableAltException(this); 6303 } 6304 } 6305 setState(799); 6306 _errHandler.sync(this); 6307 _la = _input.LA(1); 6308 } 6309 setState(800); 6310 match(CLOSE); 6311 } 6312 } 6313 catch (RecognitionException re) { 6314 _localctx.exception = re; 6315 _errHandler.reportError(this, re); 6316 _errHandler.recover(this, re); 6317 } 6318 finally { 6319 exitRule(); 6320 } 6321 return _localctx; 6322 } 6323 6324 public static class DdTagCloseContext extends ParserRuleContext { 6325 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6326 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 6327 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6328 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6329 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6330 public TerminalNode NEWLINE(int i) { 6331 return getToken(JavadocParser.NEWLINE, i); 6332 } 6333 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6334 public TerminalNode LEADING_ASTERISK(int i) { 6335 return getToken(JavadocParser.LEADING_ASTERISK, i); 6336 } 6337 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6338 public TerminalNode WS(int i) { 6339 return getToken(JavadocParser.WS, i); 6340 } 6341 public DdTagCloseContext(ParserRuleContext parent, int invokingState) { 6342 super(parent, invokingState); 6343 } 6344 @Override public int getRuleIndex() { return RULE_ddTagClose; } 6345 @Override 6346 public void enterRule(ParseTreeListener listener) { 6347 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagClose(this); 6348 } 6349 @Override 6350 public void exitRule(ParseTreeListener listener) { 6351 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagClose(this); 6352 } 6353 @Override 6354 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6355 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagClose(this); 6356 else return visitor.visitChildren(this); 6357 } 6358 } 6359 6360 public final DdTagCloseContext ddTagClose() throws RecognitionException { 6361 DdTagCloseContext _localctx = new DdTagCloseContext(_ctx, getState()); 6362 enterRule(_localctx, 56, RULE_ddTagClose); 6363 int _la; 6364 try { 6365 enterOuterAlt(_localctx, 1); 6366 { 6367 setState(802); 6368 match(OPEN); 6369 setState(803); 6370 match(SLASH); 6371 setState(804); 6372 match(DD_HTML_TAG_NAME); 6373 setState(808); 6374 _errHandler.sync(this); 6375 _la = _input.LA(1); 6376 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 6377 { 6378 { 6379 setState(805); 6380 _la = _input.LA(1); 6381 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 6382 _errHandler.recoverInline(this); 6383 } else { 6384 consume(); 6385 } 6386 } 6387 } 6388 setState(810); 6389 _errHandler.sync(this); 6390 _la = _input.LA(1); 6391 } 6392 setState(811); 6393 match(CLOSE); 6394 } 6395 } 6396 catch (RecognitionException re) { 6397 _localctx.exception = re; 6398 _errHandler.reportError(this, re); 6399 _errHandler.recover(this, re); 6400 } 6401 finally { 6402 exitRule(); 6403 } 6404 return _localctx; 6405 } 6406 6407 public static class DdContext extends ParserRuleContext { 6408 public DdTagOpenContext ddTagOpen() { 6409 return getRuleContext(DdTagOpenContext.class,0); 6410 } 6411 public DdTagCloseContext ddTagClose() { 6412 return getRuleContext(DdTagCloseContext.class,0); 6413 } 6414 public List<HtmlTagContext> htmlTag() { 6415 return getRuleContexts(HtmlTagContext.class); 6416 } 6417 public HtmlTagContext htmlTag(int i) { 6418 return getRuleContext(HtmlTagContext.class,i); 6419 } 6420 public List<SingletonTagContext> singletonTag() { 6421 return getRuleContexts(SingletonTagContext.class); 6422 } 6423 public SingletonTagContext singletonTag(int i) { 6424 return getRuleContext(SingletonTagContext.class,i); 6425 } 6426 public List<ParagraphContext> paragraph() { 6427 return getRuleContexts(ParagraphContext.class); 6428 } 6429 public ParagraphContext paragraph(int i) { 6430 return getRuleContext(ParagraphContext.class,i); 6431 } 6432 public List<LiContext> li() { 6433 return getRuleContexts(LiContext.class); 6434 } 6435 public LiContext li(int i) { 6436 return getRuleContext(LiContext.class,i); 6437 } 6438 public List<TrContext> tr() { 6439 return getRuleContexts(TrContext.class); 6440 } 6441 public TrContext tr(int i) { 6442 return getRuleContext(TrContext.class,i); 6443 } 6444 public List<TdContext> td() { 6445 return getRuleContexts(TdContext.class); 6446 } 6447 public TdContext td(int i) { 6448 return getRuleContext(TdContext.class,i); 6449 } 6450 public List<ThContext> th() { 6451 return getRuleContexts(ThContext.class); 6452 } 6453 public ThContext th(int i) { 6454 return getRuleContext(ThContext.class,i); 6455 } 6456 public List<BodyContext> body() { 6457 return getRuleContexts(BodyContext.class); 6458 } 6459 public BodyContext body(int i) { 6460 return getRuleContext(BodyContext.class,i); 6461 } 6462 public List<ColgroupContext> colgroup() { 6463 return getRuleContexts(ColgroupContext.class); 6464 } 6465 public ColgroupContext colgroup(int i) { 6466 return getRuleContext(ColgroupContext.class,i); 6467 } 6468 public List<DtContext> dt() { 6469 return getRuleContexts(DtContext.class); 6470 } 6471 public DtContext dt(int i) { 6472 return getRuleContext(DtContext.class,i); 6473 } 6474 public List<HeadContext> head() { 6475 return getRuleContexts(HeadContext.class); 6476 } 6477 public HeadContext head(int i) { 6478 return getRuleContext(HeadContext.class,i); 6479 } 6480 public List<HtmlContext> html() { 6481 return getRuleContexts(HtmlContext.class); 6482 } 6483 public HtmlContext html(int i) { 6484 return getRuleContext(HtmlContext.class,i); 6485 } 6486 public List<OptionContext> option() { 6487 return getRuleContexts(OptionContext.class); 6488 } 6489 public OptionContext option(int i) { 6490 return getRuleContext(OptionContext.class,i); 6491 } 6492 public List<TbodyContext> tbody() { 6493 return getRuleContexts(TbodyContext.class); 6494 } 6495 public TbodyContext tbody(int i) { 6496 return getRuleContext(TbodyContext.class,i); 6497 } 6498 public List<TheadContext> thead() { 6499 return getRuleContexts(TheadContext.class); 6500 } 6501 public TheadContext thead(int i) { 6502 return getRuleContext(TheadContext.class,i); 6503 } 6504 public List<TfootContext> tfoot() { 6505 return getRuleContexts(TfootContext.class); 6506 } 6507 public TfootContext tfoot(int i) { 6508 return getRuleContext(TfootContext.class,i); 6509 } 6510 public List<PTagOpenContext> pTagOpen() { 6511 return getRuleContexts(PTagOpenContext.class); 6512 } 6513 public PTagOpenContext pTagOpen(int i) { 6514 return getRuleContext(PTagOpenContext.class,i); 6515 } 6516 public List<LiTagOpenContext> liTagOpen() { 6517 return getRuleContexts(LiTagOpenContext.class); 6518 } 6519 public LiTagOpenContext liTagOpen(int i) { 6520 return getRuleContext(LiTagOpenContext.class,i); 6521 } 6522 public List<TrTagOpenContext> trTagOpen() { 6523 return getRuleContexts(TrTagOpenContext.class); 6524 } 6525 public TrTagOpenContext trTagOpen(int i) { 6526 return getRuleContext(TrTagOpenContext.class,i); 6527 } 6528 public List<TdTagOpenContext> tdTagOpen() { 6529 return getRuleContexts(TdTagOpenContext.class); 6530 } 6531 public TdTagOpenContext tdTagOpen(int i) { 6532 return getRuleContext(TdTagOpenContext.class,i); 6533 } 6534 public List<ThTagOpenContext> thTagOpen() { 6535 return getRuleContexts(ThTagOpenContext.class); 6536 } 6537 public ThTagOpenContext thTagOpen(int i) { 6538 return getRuleContext(ThTagOpenContext.class,i); 6539 } 6540 public List<BodyTagOpenContext> bodyTagOpen() { 6541 return getRuleContexts(BodyTagOpenContext.class); 6542 } 6543 public BodyTagOpenContext bodyTagOpen(int i) { 6544 return getRuleContext(BodyTagOpenContext.class,i); 6545 } 6546 public List<ColgroupTagOpenContext> colgroupTagOpen() { 6547 return getRuleContexts(ColgroupTagOpenContext.class); 6548 } 6549 public ColgroupTagOpenContext colgroupTagOpen(int i) { 6550 return getRuleContext(ColgroupTagOpenContext.class,i); 6551 } 6552 public List<DtTagOpenContext> dtTagOpen() { 6553 return getRuleContexts(DtTagOpenContext.class); 6554 } 6555 public DtTagOpenContext dtTagOpen(int i) { 6556 return getRuleContext(DtTagOpenContext.class,i); 6557 } 6558 public List<HeadTagOpenContext> headTagOpen() { 6559 return getRuleContexts(HeadTagOpenContext.class); 6560 } 6561 public HeadTagOpenContext headTagOpen(int i) { 6562 return getRuleContext(HeadTagOpenContext.class,i); 6563 } 6564 public List<HtmlTagOpenContext> htmlTagOpen() { 6565 return getRuleContexts(HtmlTagOpenContext.class); 6566 } 6567 public HtmlTagOpenContext htmlTagOpen(int i) { 6568 return getRuleContext(HtmlTagOpenContext.class,i); 6569 } 6570 public List<OptionTagOpenContext> optionTagOpen() { 6571 return getRuleContexts(OptionTagOpenContext.class); 6572 } 6573 public OptionTagOpenContext optionTagOpen(int i) { 6574 return getRuleContext(OptionTagOpenContext.class,i); 6575 } 6576 public List<TbodyTagOpenContext> tbodyTagOpen() { 6577 return getRuleContexts(TbodyTagOpenContext.class); 6578 } 6579 public TbodyTagOpenContext tbodyTagOpen(int i) { 6580 return getRuleContext(TbodyTagOpenContext.class,i); 6581 } 6582 public List<TheadTagOpenContext> theadTagOpen() { 6583 return getRuleContexts(TheadTagOpenContext.class); 6584 } 6585 public TheadTagOpenContext theadTagOpen(int i) { 6586 return getRuleContext(TheadTagOpenContext.class,i); 6587 } 6588 public List<TfootTagOpenContext> tfootTagOpen() { 6589 return getRuleContexts(TfootTagOpenContext.class); 6590 } 6591 public TfootTagOpenContext tfootTagOpen(int i) { 6592 return getRuleContext(TfootTagOpenContext.class,i); 6593 } 6594 public List<HtmlCommentContext> htmlComment() { 6595 return getRuleContexts(HtmlCommentContext.class); 6596 } 6597 public HtmlCommentContext htmlComment(int i) { 6598 return getRuleContext(HtmlCommentContext.class,i); 6599 } 6600 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 6601 public TerminalNode CDATA(int i) { 6602 return getToken(JavadocParser.CDATA, i); 6603 } 6604 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6605 public TerminalNode NEWLINE(int i) { 6606 return getToken(JavadocParser.NEWLINE, i); 6607 } 6608 public List<TextContext> text() { 6609 return getRuleContexts(TextContext.class); 6610 } 6611 public TextContext text(int i) { 6612 return getRuleContext(TextContext.class,i); 6613 } 6614 public List<JavadocInlineTagContext> javadocInlineTag() { 6615 return getRuleContexts(JavadocInlineTagContext.class); 6616 } 6617 public JavadocInlineTagContext javadocInlineTag(int i) { 6618 return getRuleContext(JavadocInlineTagContext.class,i); 6619 } 6620 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6621 public TerminalNode LEADING_ASTERISK(int i) { 6622 return getToken(JavadocParser.LEADING_ASTERISK, i); 6623 } 6624 public DdContext(ParserRuleContext parent, int invokingState) { 6625 super(parent, invokingState); 6626 } 6627 @Override public int getRuleIndex() { return RULE_dd; } 6628 @Override 6629 public void enterRule(ParseTreeListener listener) { 6630 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDd(this); 6631 } 6632 @Override 6633 public void exitRule(ParseTreeListener listener) { 6634 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDd(this); 6635 } 6636 @Override 6637 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6638 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDd(this); 6639 else return visitor.visitChildren(this); 6640 } 6641 } 6642 6643 public final DdContext dd() throws RecognitionException { 6644 DdContext _localctx = new DdContext(_ctx, getState()); 6645 enterRule(_localctx, 58, RULE_dd); 6646 try { 6647 int _alt; 6648 enterOuterAlt(_localctx, 1); 6649 { 6650 setState(813); 6651 ddTagOpen(); 6652 setState(853); 6653 _errHandler.sync(this); 6654 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6655 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6656 if ( _alt==1 ) { 6657 { 6658 setState(851); 6659 switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { 6660 case 1: 6661 { 6662 setState(814); 6663 htmlTag(); 6664 } 6665 break; 6666 case 2: 6667 { 6668 setState(815); 6669 singletonTag(); 6670 } 6671 break; 6672 case 3: 6673 { 6674 setState(816); 6675 paragraph(); 6676 } 6677 break; 6678 case 4: 6679 { 6680 setState(817); 6681 li(); 6682 } 6683 break; 6684 case 5: 6685 { 6686 setState(818); 6687 tr(); 6688 } 6689 break; 6690 case 6: 6691 { 6692 setState(819); 6693 td(); 6694 } 6695 break; 6696 case 7: 6697 { 6698 setState(820); 6699 th(); 6700 } 6701 break; 6702 case 8: 6703 { 6704 setState(821); 6705 body(); 6706 } 6707 break; 6708 case 9: 6709 { 6710 setState(822); 6711 colgroup(); 6712 } 6713 break; 6714 case 10: 6715 { 6716 setState(823); 6717 dt(); 6718 } 6719 break; 6720 case 11: 6721 { 6722 setState(824); 6723 head(); 6724 } 6725 break; 6726 case 12: 6727 { 6728 setState(825); 6729 html(); 6730 } 6731 break; 6732 case 13: 6733 { 6734 setState(826); 6735 option(); 6736 } 6737 break; 6738 case 14: 6739 { 6740 setState(827); 6741 tbody(); 6742 } 6743 break; 6744 case 15: 6745 { 6746 setState(828); 6747 thead(); 6748 } 6749 break; 6750 case 16: 6751 { 6752 setState(829); 6753 tfoot(); 6754 } 6755 break; 6756 case 17: 6757 { 6758 setState(830); 6759 pTagOpen(); 6760 } 6761 break; 6762 case 18: 6763 { 6764 setState(831); 6765 liTagOpen(); 6766 } 6767 break; 6768 case 19: 6769 { 6770 setState(832); 6771 trTagOpen(); 6772 } 6773 break; 6774 case 20: 6775 { 6776 setState(833); 6777 tdTagOpen(); 6778 } 6779 break; 6780 case 21: 6781 { 6782 setState(834); 6783 thTagOpen(); 6784 } 6785 break; 6786 case 22: 6787 { 6788 setState(835); 6789 bodyTagOpen(); 6790 } 6791 break; 6792 case 23: 6793 { 6794 setState(836); 6795 colgroupTagOpen(); 6796 } 6797 break; 6798 case 24: 6799 { 6800 setState(837); 6801 dtTagOpen(); 6802 } 6803 break; 6804 case 25: 6805 { 6806 setState(838); 6807 headTagOpen(); 6808 } 6809 break; 6810 case 26: 6811 { 6812 setState(839); 6813 htmlTagOpen(); 6814 } 6815 break; 6816 case 27: 6817 { 6818 setState(840); 6819 optionTagOpen(); 6820 } 6821 break; 6822 case 28: 6823 { 6824 setState(841); 6825 tbodyTagOpen(); 6826 } 6827 break; 6828 case 29: 6829 { 6830 setState(842); 6831 theadTagOpen(); 6832 } 6833 break; 6834 case 30: 6835 { 6836 setState(843); 6837 tfootTagOpen(); 6838 } 6839 break; 6840 case 31: 6841 { 6842 { 6843 setState(844); 6844 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6845 setState(845); 6846 match(LEADING_ASTERISK); 6847 } 6848 } 6849 break; 6850 case 32: 6851 { 6852 setState(846); 6853 htmlComment(); 6854 } 6855 break; 6856 case 33: 6857 { 6858 setState(847); 6859 match(CDATA); 6860 } 6861 break; 6862 case 34: 6863 { 6864 setState(848); 6865 match(NEWLINE); 6866 } 6867 break; 6868 case 35: 6869 { 6870 setState(849); 6871 text(); 6872 } 6873 break; 6874 case 36: 6875 { 6876 setState(850); 6877 javadocInlineTag(); 6878 } 6879 break; 6880 } 6881 } 6882 } 6883 setState(855); 6884 _errHandler.sync(this); 6885 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6886 } 6887 setState(856); 6888 ddTagClose(); 6889 } 6890 } 6891 catch (RecognitionException re) { 6892 _localctx.exception = re; 6893 _errHandler.reportError(this, re); 6894 _errHandler.recover(this, re); 6895 } 6896 finally { 6897 exitRule(); 6898 } 6899 return _localctx; 6900 } 6901 6902 public static class DtTagOpenContext extends ParserRuleContext { 6903 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6904 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 6905 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6906 public List<AttributeContext> attribute() { 6907 return getRuleContexts(AttributeContext.class); 6908 } 6909 public AttributeContext attribute(int i) { 6910 return getRuleContext(AttributeContext.class,i); 6911 } 6912 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6913 public TerminalNode NEWLINE(int i) { 6914 return getToken(JavadocParser.NEWLINE, i); 6915 } 6916 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6917 public TerminalNode LEADING_ASTERISK(int i) { 6918 return getToken(JavadocParser.LEADING_ASTERISK, i); 6919 } 6920 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6921 public TerminalNode WS(int i) { 6922 return getToken(JavadocParser.WS, i); 6923 } 6924 public DtTagOpenContext(ParserRuleContext parent, int invokingState) { 6925 super(parent, invokingState); 6926 } 6927 @Override public int getRuleIndex() { return RULE_dtTagOpen; } 6928 @Override 6929 public void enterRule(ParseTreeListener listener) { 6930 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagOpen(this); 6931 } 6932 @Override 6933 public void exitRule(ParseTreeListener listener) { 6934 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagOpen(this); 6935 } 6936 @Override 6937 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6938 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagOpen(this); 6939 else return visitor.visitChildren(this); 6940 } 6941 } 6942 6943 public final DtTagOpenContext dtTagOpen() throws RecognitionException { 6944 DtTagOpenContext _localctx = new DtTagOpenContext(_ctx, getState()); 6945 enterRule(_localctx, 60, RULE_dtTagOpen); 6946 int _la; 6947 try { 6948 enterOuterAlt(_localctx, 1); 6949 { 6950 setState(858); 6951 match(OPEN); 6952 setState(859); 6953 match(DT_HTML_TAG_NAME); 6954 setState(866); 6955 _errHandler.sync(this); 6956 _la = _input.LA(1); 6957 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6958 { 6959 setState(864); 6960 switch (_input.LA(1)) { 6961 case HTML_TAG_NAME: 6962 { 6963 setState(860); 6964 attribute(); 6965 } 6966 break; 6967 case NEWLINE: 6968 { 6969 setState(861); 6970 match(NEWLINE); 6971 } 6972 break; 6973 case LEADING_ASTERISK: 6974 { 6975 setState(862); 6976 match(LEADING_ASTERISK); 6977 } 6978 break; 6979 case WS: 6980 { 6981 setState(863); 6982 match(WS); 6983 } 6984 break; 6985 default: 6986 throw new NoViableAltException(this); 6987 } 6988 } 6989 setState(868); 6990 _errHandler.sync(this); 6991 _la = _input.LA(1); 6992 } 6993 setState(869); 6994 match(CLOSE); 6995 } 6996 } 6997 catch (RecognitionException re) { 6998 _localctx.exception = re; 6999 _errHandler.reportError(this, re); 7000 _errHandler.recover(this, re); 7001 } 7002 finally { 7003 exitRule(); 7004 } 7005 return _localctx; 7006 } 7007 7008 public static class DtTagCloseContext extends ParserRuleContext { 7009 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7010 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7011 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 7012 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7013 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7014 public TerminalNode NEWLINE(int i) { 7015 return getToken(JavadocParser.NEWLINE, i); 7016 } 7017 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7018 public TerminalNode LEADING_ASTERISK(int i) { 7019 return getToken(JavadocParser.LEADING_ASTERISK, i); 7020 } 7021 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7022 public TerminalNode WS(int i) { 7023 return getToken(JavadocParser.WS, i); 7024 } 7025 public DtTagCloseContext(ParserRuleContext parent, int invokingState) { 7026 super(parent, invokingState); 7027 } 7028 @Override public int getRuleIndex() { return RULE_dtTagClose; } 7029 @Override 7030 public void enterRule(ParseTreeListener listener) { 7031 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagClose(this); 7032 } 7033 @Override 7034 public void exitRule(ParseTreeListener listener) { 7035 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagClose(this); 7036 } 7037 @Override 7038 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7039 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagClose(this); 7040 else return visitor.visitChildren(this); 7041 } 7042 } 7043 7044 public final DtTagCloseContext dtTagClose() throws RecognitionException { 7045 DtTagCloseContext _localctx = new DtTagCloseContext(_ctx, getState()); 7046 enterRule(_localctx, 62, RULE_dtTagClose); 7047 int _la; 7048 try { 7049 enterOuterAlt(_localctx, 1); 7050 { 7051 setState(871); 7052 match(OPEN); 7053 setState(872); 7054 match(SLASH); 7055 setState(873); 7056 match(DT_HTML_TAG_NAME); 7057 setState(877); 7058 _errHandler.sync(this); 7059 _la = _input.LA(1); 7060 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7061 { 7062 { 7063 setState(874); 7064 _la = _input.LA(1); 7065 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7066 _errHandler.recoverInline(this); 7067 } else { 7068 consume(); 7069 } 7070 } 7071 } 7072 setState(879); 7073 _errHandler.sync(this); 7074 _la = _input.LA(1); 7075 } 7076 setState(880); 7077 match(CLOSE); 7078 } 7079 } 7080 catch (RecognitionException re) { 7081 _localctx.exception = re; 7082 _errHandler.reportError(this, re); 7083 _errHandler.recover(this, re); 7084 } 7085 finally { 7086 exitRule(); 7087 } 7088 return _localctx; 7089 } 7090 7091 public static class DtContext extends ParserRuleContext { 7092 public DtTagOpenContext dtTagOpen() { 7093 return getRuleContext(DtTagOpenContext.class,0); 7094 } 7095 public DtTagCloseContext dtTagClose() { 7096 return getRuleContext(DtTagCloseContext.class,0); 7097 } 7098 public List<HtmlTagContext> htmlTag() { 7099 return getRuleContexts(HtmlTagContext.class); 7100 } 7101 public HtmlTagContext htmlTag(int i) { 7102 return getRuleContext(HtmlTagContext.class,i); 7103 } 7104 public List<SingletonTagContext> singletonTag() { 7105 return getRuleContexts(SingletonTagContext.class); 7106 } 7107 public SingletonTagContext singletonTag(int i) { 7108 return getRuleContext(SingletonTagContext.class,i); 7109 } 7110 public List<ParagraphContext> paragraph() { 7111 return getRuleContexts(ParagraphContext.class); 7112 } 7113 public ParagraphContext paragraph(int i) { 7114 return getRuleContext(ParagraphContext.class,i); 7115 } 7116 public List<LiContext> li() { 7117 return getRuleContexts(LiContext.class); 7118 } 7119 public LiContext li(int i) { 7120 return getRuleContext(LiContext.class,i); 7121 } 7122 public List<TrContext> tr() { 7123 return getRuleContexts(TrContext.class); 7124 } 7125 public TrContext tr(int i) { 7126 return getRuleContext(TrContext.class,i); 7127 } 7128 public List<TdContext> td() { 7129 return getRuleContexts(TdContext.class); 7130 } 7131 public TdContext td(int i) { 7132 return getRuleContext(TdContext.class,i); 7133 } 7134 public List<ThContext> th() { 7135 return getRuleContexts(ThContext.class); 7136 } 7137 public ThContext th(int i) { 7138 return getRuleContext(ThContext.class,i); 7139 } 7140 public List<BodyContext> body() { 7141 return getRuleContexts(BodyContext.class); 7142 } 7143 public BodyContext body(int i) { 7144 return getRuleContext(BodyContext.class,i); 7145 } 7146 public List<ColgroupContext> colgroup() { 7147 return getRuleContexts(ColgroupContext.class); 7148 } 7149 public ColgroupContext colgroup(int i) { 7150 return getRuleContext(ColgroupContext.class,i); 7151 } 7152 public List<DdContext> dd() { 7153 return getRuleContexts(DdContext.class); 7154 } 7155 public DdContext dd(int i) { 7156 return getRuleContext(DdContext.class,i); 7157 } 7158 public List<HeadContext> head() { 7159 return getRuleContexts(HeadContext.class); 7160 } 7161 public HeadContext head(int i) { 7162 return getRuleContext(HeadContext.class,i); 7163 } 7164 public List<HtmlContext> html() { 7165 return getRuleContexts(HtmlContext.class); 7166 } 7167 public HtmlContext html(int i) { 7168 return getRuleContext(HtmlContext.class,i); 7169 } 7170 public List<OptionContext> option() { 7171 return getRuleContexts(OptionContext.class); 7172 } 7173 public OptionContext option(int i) { 7174 return getRuleContext(OptionContext.class,i); 7175 } 7176 public List<TbodyContext> tbody() { 7177 return getRuleContexts(TbodyContext.class); 7178 } 7179 public TbodyContext tbody(int i) { 7180 return getRuleContext(TbodyContext.class,i); 7181 } 7182 public List<TheadContext> thead() { 7183 return getRuleContexts(TheadContext.class); 7184 } 7185 public TheadContext thead(int i) { 7186 return getRuleContext(TheadContext.class,i); 7187 } 7188 public List<TfootContext> tfoot() { 7189 return getRuleContexts(TfootContext.class); 7190 } 7191 public TfootContext tfoot(int i) { 7192 return getRuleContext(TfootContext.class,i); 7193 } 7194 public List<PTagOpenContext> pTagOpen() { 7195 return getRuleContexts(PTagOpenContext.class); 7196 } 7197 public PTagOpenContext pTagOpen(int i) { 7198 return getRuleContext(PTagOpenContext.class,i); 7199 } 7200 public List<LiTagOpenContext> liTagOpen() { 7201 return getRuleContexts(LiTagOpenContext.class); 7202 } 7203 public LiTagOpenContext liTagOpen(int i) { 7204 return getRuleContext(LiTagOpenContext.class,i); 7205 } 7206 public List<TrTagOpenContext> trTagOpen() { 7207 return getRuleContexts(TrTagOpenContext.class); 7208 } 7209 public TrTagOpenContext trTagOpen(int i) { 7210 return getRuleContext(TrTagOpenContext.class,i); 7211 } 7212 public List<TdTagOpenContext> tdTagOpen() { 7213 return getRuleContexts(TdTagOpenContext.class); 7214 } 7215 public TdTagOpenContext tdTagOpen(int i) { 7216 return getRuleContext(TdTagOpenContext.class,i); 7217 } 7218 public List<ThTagOpenContext> thTagOpen() { 7219 return getRuleContexts(ThTagOpenContext.class); 7220 } 7221 public ThTagOpenContext thTagOpen(int i) { 7222 return getRuleContext(ThTagOpenContext.class,i); 7223 } 7224 public List<BodyTagOpenContext> bodyTagOpen() { 7225 return getRuleContexts(BodyTagOpenContext.class); 7226 } 7227 public BodyTagOpenContext bodyTagOpen(int i) { 7228 return getRuleContext(BodyTagOpenContext.class,i); 7229 } 7230 public List<ColgroupTagOpenContext> colgroupTagOpen() { 7231 return getRuleContexts(ColgroupTagOpenContext.class); 7232 } 7233 public ColgroupTagOpenContext colgroupTagOpen(int i) { 7234 return getRuleContext(ColgroupTagOpenContext.class,i); 7235 } 7236 public List<DdTagOpenContext> ddTagOpen() { 7237 return getRuleContexts(DdTagOpenContext.class); 7238 } 7239 public DdTagOpenContext ddTagOpen(int i) { 7240 return getRuleContext(DdTagOpenContext.class,i); 7241 } 7242 public List<HeadTagOpenContext> headTagOpen() { 7243 return getRuleContexts(HeadTagOpenContext.class); 7244 } 7245 public HeadTagOpenContext headTagOpen(int i) { 7246 return getRuleContext(HeadTagOpenContext.class,i); 7247 } 7248 public List<HtmlTagOpenContext> htmlTagOpen() { 7249 return getRuleContexts(HtmlTagOpenContext.class); 7250 } 7251 public HtmlTagOpenContext htmlTagOpen(int i) { 7252 return getRuleContext(HtmlTagOpenContext.class,i); 7253 } 7254 public List<OptionTagOpenContext> optionTagOpen() { 7255 return getRuleContexts(OptionTagOpenContext.class); 7256 } 7257 public OptionTagOpenContext optionTagOpen(int i) { 7258 return getRuleContext(OptionTagOpenContext.class,i); 7259 } 7260 public List<TbodyTagOpenContext> tbodyTagOpen() { 7261 return getRuleContexts(TbodyTagOpenContext.class); 7262 } 7263 public TbodyTagOpenContext tbodyTagOpen(int i) { 7264 return getRuleContext(TbodyTagOpenContext.class,i); 7265 } 7266 public List<TheadTagOpenContext> theadTagOpen() { 7267 return getRuleContexts(TheadTagOpenContext.class); 7268 } 7269 public TheadTagOpenContext theadTagOpen(int i) { 7270 return getRuleContext(TheadTagOpenContext.class,i); 7271 } 7272 public List<TfootTagOpenContext> tfootTagOpen() { 7273 return getRuleContexts(TfootTagOpenContext.class); 7274 } 7275 public TfootTagOpenContext tfootTagOpen(int i) { 7276 return getRuleContext(TfootTagOpenContext.class,i); 7277 } 7278 public List<HtmlCommentContext> htmlComment() { 7279 return getRuleContexts(HtmlCommentContext.class); 7280 } 7281 public HtmlCommentContext htmlComment(int i) { 7282 return getRuleContext(HtmlCommentContext.class,i); 7283 } 7284 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 7285 public TerminalNode CDATA(int i) { 7286 return getToken(JavadocParser.CDATA, i); 7287 } 7288 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7289 public TerminalNode NEWLINE(int i) { 7290 return getToken(JavadocParser.NEWLINE, i); 7291 } 7292 public List<TextContext> text() { 7293 return getRuleContexts(TextContext.class); 7294 } 7295 public TextContext text(int i) { 7296 return getRuleContext(TextContext.class,i); 7297 } 7298 public List<JavadocInlineTagContext> javadocInlineTag() { 7299 return getRuleContexts(JavadocInlineTagContext.class); 7300 } 7301 public JavadocInlineTagContext javadocInlineTag(int i) { 7302 return getRuleContext(JavadocInlineTagContext.class,i); 7303 } 7304 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7305 public TerminalNode LEADING_ASTERISK(int i) { 7306 return getToken(JavadocParser.LEADING_ASTERISK, i); 7307 } 7308 public DtContext(ParserRuleContext parent, int invokingState) { 7309 super(parent, invokingState); 7310 } 7311 @Override public int getRuleIndex() { return RULE_dt; } 7312 @Override 7313 public void enterRule(ParseTreeListener listener) { 7314 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDt(this); 7315 } 7316 @Override 7317 public void exitRule(ParseTreeListener listener) { 7318 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDt(this); 7319 } 7320 @Override 7321 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7322 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDt(this); 7323 else return visitor.visitChildren(this); 7324 } 7325 } 7326 7327 public final DtContext dt() throws RecognitionException { 7328 DtContext _localctx = new DtContext(_ctx, getState()); 7329 enterRule(_localctx, 64, RULE_dt); 7330 try { 7331 int _alt; 7332 enterOuterAlt(_localctx, 1); 7333 { 7334 setState(882); 7335 dtTagOpen(); 7336 setState(922); 7337 _errHandler.sync(this); 7338 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 7339 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 7340 if ( _alt==1 ) { 7341 { 7342 setState(920); 7343 switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { 7344 case 1: 7345 { 7346 setState(883); 7347 htmlTag(); 7348 } 7349 break; 7350 case 2: 7351 { 7352 setState(884); 7353 singletonTag(); 7354 } 7355 break; 7356 case 3: 7357 { 7358 setState(885); 7359 paragraph(); 7360 } 7361 break; 7362 case 4: 7363 { 7364 setState(886); 7365 li(); 7366 } 7367 break; 7368 case 5: 7369 { 7370 setState(887); 7371 tr(); 7372 } 7373 break; 7374 case 6: 7375 { 7376 setState(888); 7377 td(); 7378 } 7379 break; 7380 case 7: 7381 { 7382 setState(889); 7383 th(); 7384 } 7385 break; 7386 case 8: 7387 { 7388 setState(890); 7389 body(); 7390 } 7391 break; 7392 case 9: 7393 { 7394 setState(891); 7395 colgroup(); 7396 } 7397 break; 7398 case 10: 7399 { 7400 setState(892); 7401 dd(); 7402 } 7403 break; 7404 case 11: 7405 { 7406 setState(893); 7407 head(); 7408 } 7409 break; 7410 case 12: 7411 { 7412 setState(894); 7413 html(); 7414 } 7415 break; 7416 case 13: 7417 { 7418 setState(895); 7419 option(); 7420 } 7421 break; 7422 case 14: 7423 { 7424 setState(896); 7425 tbody(); 7426 } 7427 break; 7428 case 15: 7429 { 7430 setState(897); 7431 thead(); 7432 } 7433 break; 7434 case 16: 7435 { 7436 setState(898); 7437 tfoot(); 7438 } 7439 break; 7440 case 17: 7441 { 7442 setState(899); 7443 pTagOpen(); 7444 } 7445 break; 7446 case 18: 7447 { 7448 setState(900); 7449 liTagOpen(); 7450 } 7451 break; 7452 case 19: 7453 { 7454 setState(901); 7455 trTagOpen(); 7456 } 7457 break; 7458 case 20: 7459 { 7460 setState(902); 7461 tdTagOpen(); 7462 } 7463 break; 7464 case 21: 7465 { 7466 setState(903); 7467 thTagOpen(); 7468 } 7469 break; 7470 case 22: 7471 { 7472 setState(904); 7473 bodyTagOpen(); 7474 } 7475 break; 7476 case 23: 7477 { 7478 setState(905); 7479 colgroupTagOpen(); 7480 } 7481 break; 7482 case 24: 7483 { 7484 setState(906); 7485 ddTagOpen(); 7486 } 7487 break; 7488 case 25: 7489 { 7490 setState(907); 7491 headTagOpen(); 7492 } 7493 break; 7494 case 26: 7495 { 7496 setState(908); 7497 htmlTagOpen(); 7498 } 7499 break; 7500 case 27: 7501 { 7502 setState(909); 7503 optionTagOpen(); 7504 } 7505 break; 7506 case 28: 7507 { 7508 setState(910); 7509 tbodyTagOpen(); 7510 } 7511 break; 7512 case 29: 7513 { 7514 setState(911); 7515 theadTagOpen(); 7516 } 7517 break; 7518 case 30: 7519 { 7520 setState(912); 7521 tfootTagOpen(); 7522 } 7523 break; 7524 case 31: 7525 { 7526 { 7527 setState(913); 7528 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 7529 setState(914); 7530 match(LEADING_ASTERISK); 7531 } 7532 } 7533 break; 7534 case 32: 7535 { 7536 setState(915); 7537 htmlComment(); 7538 } 7539 break; 7540 case 33: 7541 { 7542 setState(916); 7543 match(CDATA); 7544 } 7545 break; 7546 case 34: 7547 { 7548 setState(917); 7549 match(NEWLINE); 7550 } 7551 break; 7552 case 35: 7553 { 7554 setState(918); 7555 text(); 7556 } 7557 break; 7558 case 36: 7559 { 7560 setState(919); 7561 javadocInlineTag(); 7562 } 7563 break; 7564 } 7565 } 7566 } 7567 setState(924); 7568 _errHandler.sync(this); 7569 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 7570 } 7571 setState(925); 7572 dtTagClose(); 7573 } 7574 } 7575 catch (RecognitionException re) { 7576 _localctx.exception = re; 7577 _errHandler.reportError(this, re); 7578 _errHandler.recover(this, re); 7579 } 7580 finally { 7581 exitRule(); 7582 } 7583 return _localctx; 7584 } 7585 7586 public static class HeadTagOpenContext extends ParserRuleContext { 7587 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7588 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7589 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7590 public List<AttributeContext> attribute() { 7591 return getRuleContexts(AttributeContext.class); 7592 } 7593 public AttributeContext attribute(int i) { 7594 return getRuleContext(AttributeContext.class,i); 7595 } 7596 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7597 public TerminalNode NEWLINE(int i) { 7598 return getToken(JavadocParser.NEWLINE, i); 7599 } 7600 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7601 public TerminalNode LEADING_ASTERISK(int i) { 7602 return getToken(JavadocParser.LEADING_ASTERISK, i); 7603 } 7604 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7605 public TerminalNode WS(int i) { 7606 return getToken(JavadocParser.WS, i); 7607 } 7608 public HeadTagOpenContext(ParserRuleContext parent, int invokingState) { 7609 super(parent, invokingState); 7610 } 7611 @Override public int getRuleIndex() { return RULE_headTagOpen; } 7612 @Override 7613 public void enterRule(ParseTreeListener listener) { 7614 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagOpen(this); 7615 } 7616 @Override 7617 public void exitRule(ParseTreeListener listener) { 7618 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagOpen(this); 7619 } 7620 @Override 7621 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7622 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagOpen(this); 7623 else return visitor.visitChildren(this); 7624 } 7625 } 7626 7627 public final HeadTagOpenContext headTagOpen() throws RecognitionException { 7628 HeadTagOpenContext _localctx = new HeadTagOpenContext(_ctx, getState()); 7629 enterRule(_localctx, 66, RULE_headTagOpen); 7630 int _la; 7631 try { 7632 enterOuterAlt(_localctx, 1); 7633 { 7634 setState(927); 7635 match(OPEN); 7636 setState(928); 7637 match(HEAD_HTML_TAG_NAME); 7638 setState(935); 7639 _errHandler.sync(this); 7640 _la = _input.LA(1); 7641 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 7642 { 7643 setState(933); 7644 switch (_input.LA(1)) { 7645 case HTML_TAG_NAME: 7646 { 7647 setState(929); 7648 attribute(); 7649 } 7650 break; 7651 case NEWLINE: 7652 { 7653 setState(930); 7654 match(NEWLINE); 7655 } 7656 break; 7657 case LEADING_ASTERISK: 7658 { 7659 setState(931); 7660 match(LEADING_ASTERISK); 7661 } 7662 break; 7663 case WS: 7664 { 7665 setState(932); 7666 match(WS); 7667 } 7668 break; 7669 default: 7670 throw new NoViableAltException(this); 7671 } 7672 } 7673 setState(937); 7674 _errHandler.sync(this); 7675 _la = _input.LA(1); 7676 } 7677 setState(938); 7678 match(CLOSE); 7679 } 7680 } 7681 catch (RecognitionException re) { 7682 _localctx.exception = re; 7683 _errHandler.reportError(this, re); 7684 _errHandler.recover(this, re); 7685 } 7686 finally { 7687 exitRule(); 7688 } 7689 return _localctx; 7690 } 7691 7692 public static class HeadTagCloseContext extends ParserRuleContext { 7693 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7694 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7695 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7696 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7697 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7698 public TerminalNode NEWLINE(int i) { 7699 return getToken(JavadocParser.NEWLINE, i); 7700 } 7701 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7702 public TerminalNode LEADING_ASTERISK(int i) { 7703 return getToken(JavadocParser.LEADING_ASTERISK, i); 7704 } 7705 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7706 public TerminalNode WS(int i) { 7707 return getToken(JavadocParser.WS, i); 7708 } 7709 public HeadTagCloseContext(ParserRuleContext parent, int invokingState) { 7710 super(parent, invokingState); 7711 } 7712 @Override public int getRuleIndex() { return RULE_headTagClose; } 7713 @Override 7714 public void enterRule(ParseTreeListener listener) { 7715 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagClose(this); 7716 } 7717 @Override 7718 public void exitRule(ParseTreeListener listener) { 7719 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagClose(this); 7720 } 7721 @Override 7722 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7723 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagClose(this); 7724 else return visitor.visitChildren(this); 7725 } 7726 } 7727 7728 public final HeadTagCloseContext headTagClose() throws RecognitionException { 7729 HeadTagCloseContext _localctx = new HeadTagCloseContext(_ctx, getState()); 7730 enterRule(_localctx, 68, RULE_headTagClose); 7731 int _la; 7732 try { 7733 enterOuterAlt(_localctx, 1); 7734 { 7735 setState(940); 7736 match(OPEN); 7737 setState(941); 7738 match(SLASH); 7739 setState(942); 7740 match(HEAD_HTML_TAG_NAME); 7741 setState(946); 7742 _errHandler.sync(this); 7743 _la = _input.LA(1); 7744 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7745 { 7746 { 7747 setState(943); 7748 _la = _input.LA(1); 7749 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7750 _errHandler.recoverInline(this); 7751 } else { 7752 consume(); 7753 } 7754 } 7755 } 7756 setState(948); 7757 _errHandler.sync(this); 7758 _la = _input.LA(1); 7759 } 7760 setState(949); 7761 match(CLOSE); 7762 } 7763 } 7764 catch (RecognitionException re) { 7765 _localctx.exception = re; 7766 _errHandler.reportError(this, re); 7767 _errHandler.recover(this, re); 7768 } 7769 finally { 7770 exitRule(); 7771 } 7772 return _localctx; 7773 } 7774 7775 public static class HeadContext extends ParserRuleContext { 7776 public HeadTagOpenContext headTagOpen() { 7777 return getRuleContext(HeadTagOpenContext.class,0); 7778 } 7779 public HeadTagCloseContext headTagClose() { 7780 return getRuleContext(HeadTagCloseContext.class,0); 7781 } 7782 public List<HtmlTagContext> htmlTag() { 7783 return getRuleContexts(HtmlTagContext.class); 7784 } 7785 public HtmlTagContext htmlTag(int i) { 7786 return getRuleContext(HtmlTagContext.class,i); 7787 } 7788 public List<SingletonTagContext> singletonTag() { 7789 return getRuleContexts(SingletonTagContext.class); 7790 } 7791 public SingletonTagContext singletonTag(int i) { 7792 return getRuleContext(SingletonTagContext.class,i); 7793 } 7794 public List<ParagraphContext> paragraph() { 7795 return getRuleContexts(ParagraphContext.class); 7796 } 7797 public ParagraphContext paragraph(int i) { 7798 return getRuleContext(ParagraphContext.class,i); 7799 } 7800 public List<LiContext> li() { 7801 return getRuleContexts(LiContext.class); 7802 } 7803 public LiContext li(int i) { 7804 return getRuleContext(LiContext.class,i); 7805 } 7806 public List<TrContext> tr() { 7807 return getRuleContexts(TrContext.class); 7808 } 7809 public TrContext tr(int i) { 7810 return getRuleContext(TrContext.class,i); 7811 } 7812 public List<TdContext> td() { 7813 return getRuleContexts(TdContext.class); 7814 } 7815 public TdContext td(int i) { 7816 return getRuleContext(TdContext.class,i); 7817 } 7818 public List<ThContext> th() { 7819 return getRuleContexts(ThContext.class); 7820 } 7821 public ThContext th(int i) { 7822 return getRuleContext(ThContext.class,i); 7823 } 7824 public List<BodyContext> body() { 7825 return getRuleContexts(BodyContext.class); 7826 } 7827 public BodyContext body(int i) { 7828 return getRuleContext(BodyContext.class,i); 7829 } 7830 public List<ColgroupContext> colgroup() { 7831 return getRuleContexts(ColgroupContext.class); 7832 } 7833 public ColgroupContext colgroup(int i) { 7834 return getRuleContext(ColgroupContext.class,i); 7835 } 7836 public List<DdContext> dd() { 7837 return getRuleContexts(DdContext.class); 7838 } 7839 public DdContext dd(int i) { 7840 return getRuleContext(DdContext.class,i); 7841 } 7842 public List<DtContext> dt() { 7843 return getRuleContexts(DtContext.class); 7844 } 7845 public DtContext dt(int i) { 7846 return getRuleContext(DtContext.class,i); 7847 } 7848 public List<HtmlContext> html() { 7849 return getRuleContexts(HtmlContext.class); 7850 } 7851 public HtmlContext html(int i) { 7852 return getRuleContext(HtmlContext.class,i); 7853 } 7854 public List<OptionContext> option() { 7855 return getRuleContexts(OptionContext.class); 7856 } 7857 public OptionContext option(int i) { 7858 return getRuleContext(OptionContext.class,i); 7859 } 7860 public List<TbodyContext> tbody() { 7861 return getRuleContexts(TbodyContext.class); 7862 } 7863 public TbodyContext tbody(int i) { 7864 return getRuleContext(TbodyContext.class,i); 7865 } 7866 public List<TheadContext> thead() { 7867 return getRuleContexts(TheadContext.class); 7868 } 7869 public TheadContext thead(int i) { 7870 return getRuleContext(TheadContext.class,i); 7871 } 7872 public List<TfootContext> tfoot() { 7873 return getRuleContexts(TfootContext.class); 7874 } 7875 public TfootContext tfoot(int i) { 7876 return getRuleContext(TfootContext.class,i); 7877 } 7878 public List<PTagOpenContext> pTagOpen() { 7879 return getRuleContexts(PTagOpenContext.class); 7880 } 7881 public PTagOpenContext pTagOpen(int i) { 7882 return getRuleContext(PTagOpenContext.class,i); 7883 } 7884 public List<LiTagOpenContext> liTagOpen() { 7885 return getRuleContexts(LiTagOpenContext.class); 7886 } 7887 public LiTagOpenContext liTagOpen(int i) { 7888 return getRuleContext(LiTagOpenContext.class,i); 7889 } 7890 public List<TrTagOpenContext> trTagOpen() { 7891 return getRuleContexts(TrTagOpenContext.class); 7892 } 7893 public TrTagOpenContext trTagOpen(int i) { 7894 return getRuleContext(TrTagOpenContext.class,i); 7895 } 7896 public List<TdTagOpenContext> tdTagOpen() { 7897 return getRuleContexts(TdTagOpenContext.class); 7898 } 7899 public TdTagOpenContext tdTagOpen(int i) { 7900 return getRuleContext(TdTagOpenContext.class,i); 7901 } 7902 public List<ThTagOpenContext> thTagOpen() { 7903 return getRuleContexts(ThTagOpenContext.class); 7904 } 7905 public ThTagOpenContext thTagOpen(int i) { 7906 return getRuleContext(ThTagOpenContext.class,i); 7907 } 7908 public List<BodyTagOpenContext> bodyTagOpen() { 7909 return getRuleContexts(BodyTagOpenContext.class); 7910 } 7911 public BodyTagOpenContext bodyTagOpen(int i) { 7912 return getRuleContext(BodyTagOpenContext.class,i); 7913 } 7914 public List<ColgroupTagOpenContext> colgroupTagOpen() { 7915 return getRuleContexts(ColgroupTagOpenContext.class); 7916 } 7917 public ColgroupTagOpenContext colgroupTagOpen(int i) { 7918 return getRuleContext(ColgroupTagOpenContext.class,i); 7919 } 7920 public List<DdTagOpenContext> ddTagOpen() { 7921 return getRuleContexts(DdTagOpenContext.class); 7922 } 7923 public DdTagOpenContext ddTagOpen(int i) { 7924 return getRuleContext(DdTagOpenContext.class,i); 7925 } 7926 public List<DtTagOpenContext> dtTagOpen() { 7927 return getRuleContexts(DtTagOpenContext.class); 7928 } 7929 public DtTagOpenContext dtTagOpen(int i) { 7930 return getRuleContext(DtTagOpenContext.class,i); 7931 } 7932 public List<HtmlTagOpenContext> htmlTagOpen() { 7933 return getRuleContexts(HtmlTagOpenContext.class); 7934 } 7935 public HtmlTagOpenContext htmlTagOpen(int i) { 7936 return getRuleContext(HtmlTagOpenContext.class,i); 7937 } 7938 public List<OptionTagOpenContext> optionTagOpen() { 7939 return getRuleContexts(OptionTagOpenContext.class); 7940 } 7941 public OptionTagOpenContext optionTagOpen(int i) { 7942 return getRuleContext(OptionTagOpenContext.class,i); 7943 } 7944 public List<TbodyTagOpenContext> tbodyTagOpen() { 7945 return getRuleContexts(TbodyTagOpenContext.class); 7946 } 7947 public TbodyTagOpenContext tbodyTagOpen(int i) { 7948 return getRuleContext(TbodyTagOpenContext.class,i); 7949 } 7950 public List<TheadTagOpenContext> theadTagOpen() { 7951 return getRuleContexts(TheadTagOpenContext.class); 7952 } 7953 public TheadTagOpenContext theadTagOpen(int i) { 7954 return getRuleContext(TheadTagOpenContext.class,i); 7955 } 7956 public List<TfootTagOpenContext> tfootTagOpen() { 7957 return getRuleContexts(TfootTagOpenContext.class); 7958 } 7959 public TfootTagOpenContext tfootTagOpen(int i) { 7960 return getRuleContext(TfootTagOpenContext.class,i); 7961 } 7962 public List<HtmlCommentContext> htmlComment() { 7963 return getRuleContexts(HtmlCommentContext.class); 7964 } 7965 public HtmlCommentContext htmlComment(int i) { 7966 return getRuleContext(HtmlCommentContext.class,i); 7967 } 7968 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 7969 public TerminalNode CDATA(int i) { 7970 return getToken(JavadocParser.CDATA, i); 7971 } 7972 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7973 public TerminalNode NEWLINE(int i) { 7974 return getToken(JavadocParser.NEWLINE, i); 7975 } 7976 public List<TextContext> text() { 7977 return getRuleContexts(TextContext.class); 7978 } 7979 public TextContext text(int i) { 7980 return getRuleContext(TextContext.class,i); 7981 } 7982 public List<JavadocInlineTagContext> javadocInlineTag() { 7983 return getRuleContexts(JavadocInlineTagContext.class); 7984 } 7985 public JavadocInlineTagContext javadocInlineTag(int i) { 7986 return getRuleContext(JavadocInlineTagContext.class,i); 7987 } 7988 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7989 public TerminalNode LEADING_ASTERISK(int i) { 7990 return getToken(JavadocParser.LEADING_ASTERISK, i); 7991 } 7992 public HeadContext(ParserRuleContext parent, int invokingState) { 7993 super(parent, invokingState); 7994 } 7995 @Override public int getRuleIndex() { return RULE_head; } 7996 @Override 7997 public void enterRule(ParseTreeListener listener) { 7998 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHead(this); 7999 } 8000 @Override 8001 public void exitRule(ParseTreeListener listener) { 8002 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHead(this); 8003 } 8004 @Override 8005 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8006 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHead(this); 8007 else return visitor.visitChildren(this); 8008 } 8009 } 8010 8011 public final HeadContext head() throws RecognitionException { 8012 HeadContext _localctx = new HeadContext(_ctx, getState()); 8013 enterRule(_localctx, 70, RULE_head); 8014 try { 8015 int _alt; 8016 enterOuterAlt(_localctx, 1); 8017 { 8018 setState(951); 8019 headTagOpen(); 8020 setState(991); 8021 _errHandler.sync(this); 8022 _alt = getInterpreter().adaptivePredict(_input,66,_ctx); 8023 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8024 if ( _alt==1 ) { 8025 { 8026 setState(989); 8027 switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) { 8028 case 1: 8029 { 8030 setState(952); 8031 htmlTag(); 8032 } 8033 break; 8034 case 2: 8035 { 8036 setState(953); 8037 singletonTag(); 8038 } 8039 break; 8040 case 3: 8041 { 8042 setState(954); 8043 paragraph(); 8044 } 8045 break; 8046 case 4: 8047 { 8048 setState(955); 8049 li(); 8050 } 8051 break; 8052 case 5: 8053 { 8054 setState(956); 8055 tr(); 8056 } 8057 break; 8058 case 6: 8059 { 8060 setState(957); 8061 td(); 8062 } 8063 break; 8064 case 7: 8065 { 8066 setState(958); 8067 th(); 8068 } 8069 break; 8070 case 8: 8071 { 8072 setState(959); 8073 body(); 8074 } 8075 break; 8076 case 9: 8077 { 8078 setState(960); 8079 colgroup(); 8080 } 8081 break; 8082 case 10: 8083 { 8084 setState(961); 8085 dd(); 8086 } 8087 break; 8088 case 11: 8089 { 8090 setState(962); 8091 dt(); 8092 } 8093 break; 8094 case 12: 8095 { 8096 setState(963); 8097 html(); 8098 } 8099 break; 8100 case 13: 8101 { 8102 setState(964); 8103 option(); 8104 } 8105 break; 8106 case 14: 8107 { 8108 setState(965); 8109 tbody(); 8110 } 8111 break; 8112 case 15: 8113 { 8114 setState(966); 8115 thead(); 8116 } 8117 break; 8118 case 16: 8119 { 8120 setState(967); 8121 tfoot(); 8122 } 8123 break; 8124 case 17: 8125 { 8126 setState(968); 8127 pTagOpen(); 8128 } 8129 break; 8130 case 18: 8131 { 8132 setState(969); 8133 liTagOpen(); 8134 } 8135 break; 8136 case 19: 8137 { 8138 setState(970); 8139 trTagOpen(); 8140 } 8141 break; 8142 case 20: 8143 { 8144 setState(971); 8145 tdTagOpen(); 8146 } 8147 break; 8148 case 21: 8149 { 8150 setState(972); 8151 thTagOpen(); 8152 } 8153 break; 8154 case 22: 8155 { 8156 setState(973); 8157 bodyTagOpen(); 8158 } 8159 break; 8160 case 23: 8161 { 8162 setState(974); 8163 colgroupTagOpen(); 8164 } 8165 break; 8166 case 24: 8167 { 8168 setState(975); 8169 ddTagOpen(); 8170 } 8171 break; 8172 case 25: 8173 { 8174 setState(976); 8175 dtTagOpen(); 8176 } 8177 break; 8178 case 26: 8179 { 8180 setState(977); 8181 htmlTagOpen(); 8182 } 8183 break; 8184 case 27: 8185 { 8186 setState(978); 8187 optionTagOpen(); 8188 } 8189 break; 8190 case 28: 8191 { 8192 setState(979); 8193 tbodyTagOpen(); 8194 } 8195 break; 8196 case 29: 8197 { 8198 setState(980); 8199 theadTagOpen(); 8200 } 8201 break; 8202 case 30: 8203 { 8204 setState(981); 8205 tfootTagOpen(); 8206 } 8207 break; 8208 case 31: 8209 { 8210 { 8211 setState(982); 8212 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8213 setState(983); 8214 match(LEADING_ASTERISK); 8215 } 8216 } 8217 break; 8218 case 32: 8219 { 8220 setState(984); 8221 htmlComment(); 8222 } 8223 break; 8224 case 33: 8225 { 8226 setState(985); 8227 match(CDATA); 8228 } 8229 break; 8230 case 34: 8231 { 8232 setState(986); 8233 match(NEWLINE); 8234 } 8235 break; 8236 case 35: 8237 { 8238 setState(987); 8239 text(); 8240 } 8241 break; 8242 case 36: 8243 { 8244 setState(988); 8245 javadocInlineTag(); 8246 } 8247 break; 8248 } 8249 } 8250 } 8251 setState(993); 8252 _errHandler.sync(this); 8253 _alt = getInterpreter().adaptivePredict(_input,66,_ctx); 8254 } 8255 setState(994); 8256 headTagClose(); 8257 } 8258 } 8259 catch (RecognitionException re) { 8260 _localctx.exception = re; 8261 _errHandler.reportError(this, re); 8262 _errHandler.recover(this, re); 8263 } 8264 finally { 8265 exitRule(); 8266 } 8267 return _localctx; 8268 } 8269 8270 public static class HtmlTagOpenContext extends ParserRuleContext { 8271 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8272 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 8273 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8274 public List<AttributeContext> attribute() { 8275 return getRuleContexts(AttributeContext.class); 8276 } 8277 public AttributeContext attribute(int i) { 8278 return getRuleContext(AttributeContext.class,i); 8279 } 8280 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8281 public TerminalNode NEWLINE(int i) { 8282 return getToken(JavadocParser.NEWLINE, i); 8283 } 8284 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8285 public TerminalNode LEADING_ASTERISK(int i) { 8286 return getToken(JavadocParser.LEADING_ASTERISK, i); 8287 } 8288 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8289 public TerminalNode WS(int i) { 8290 return getToken(JavadocParser.WS, i); 8291 } 8292 public HtmlTagOpenContext(ParserRuleContext parent, int invokingState) { 8293 super(parent, invokingState); 8294 } 8295 @Override public int getRuleIndex() { return RULE_htmlTagOpen; } 8296 @Override 8297 public void enterRule(ParseTreeListener listener) { 8298 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagOpen(this); 8299 } 8300 @Override 8301 public void exitRule(ParseTreeListener listener) { 8302 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagOpen(this); 8303 } 8304 @Override 8305 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8306 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagOpen(this); 8307 else return visitor.visitChildren(this); 8308 } 8309 } 8310 8311 public final HtmlTagOpenContext htmlTagOpen() throws RecognitionException { 8312 HtmlTagOpenContext _localctx = new HtmlTagOpenContext(_ctx, getState()); 8313 enterRule(_localctx, 72, RULE_htmlTagOpen); 8314 int _la; 8315 try { 8316 enterOuterAlt(_localctx, 1); 8317 { 8318 setState(996); 8319 match(OPEN); 8320 setState(997); 8321 match(HTML_HTML_TAG_NAME); 8322 setState(1004); 8323 _errHandler.sync(this); 8324 _la = _input.LA(1); 8325 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 8326 { 8327 setState(1002); 8328 switch (_input.LA(1)) { 8329 case HTML_TAG_NAME: 8330 { 8331 setState(998); 8332 attribute(); 8333 } 8334 break; 8335 case NEWLINE: 8336 { 8337 setState(999); 8338 match(NEWLINE); 8339 } 8340 break; 8341 case LEADING_ASTERISK: 8342 { 8343 setState(1000); 8344 match(LEADING_ASTERISK); 8345 } 8346 break; 8347 case WS: 8348 { 8349 setState(1001); 8350 match(WS); 8351 } 8352 break; 8353 default: 8354 throw new NoViableAltException(this); 8355 } 8356 } 8357 setState(1006); 8358 _errHandler.sync(this); 8359 _la = _input.LA(1); 8360 } 8361 setState(1007); 8362 match(CLOSE); 8363 } 8364 } 8365 catch (RecognitionException re) { 8366 _localctx.exception = re; 8367 _errHandler.reportError(this, re); 8368 _errHandler.recover(this, re); 8369 } 8370 finally { 8371 exitRule(); 8372 } 8373 return _localctx; 8374 } 8375 8376 public static class HtmlTagCloseContext extends ParserRuleContext { 8377 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8378 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 8379 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 8380 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8381 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8382 public TerminalNode NEWLINE(int i) { 8383 return getToken(JavadocParser.NEWLINE, i); 8384 } 8385 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8386 public TerminalNode LEADING_ASTERISK(int i) { 8387 return getToken(JavadocParser.LEADING_ASTERISK, i); 8388 } 8389 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8390 public TerminalNode WS(int i) { 8391 return getToken(JavadocParser.WS, i); 8392 } 8393 public HtmlTagCloseContext(ParserRuleContext parent, int invokingState) { 8394 super(parent, invokingState); 8395 } 8396 @Override public int getRuleIndex() { return RULE_htmlTagClose; } 8397 @Override 8398 public void enterRule(ParseTreeListener listener) { 8399 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagClose(this); 8400 } 8401 @Override 8402 public void exitRule(ParseTreeListener listener) { 8403 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagClose(this); 8404 } 8405 @Override 8406 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8407 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagClose(this); 8408 else return visitor.visitChildren(this); 8409 } 8410 } 8411 8412 public final HtmlTagCloseContext htmlTagClose() throws RecognitionException { 8413 HtmlTagCloseContext _localctx = new HtmlTagCloseContext(_ctx, getState()); 8414 enterRule(_localctx, 74, RULE_htmlTagClose); 8415 int _la; 8416 try { 8417 enterOuterAlt(_localctx, 1); 8418 { 8419 setState(1009); 8420 match(OPEN); 8421 setState(1010); 8422 match(SLASH); 8423 setState(1011); 8424 match(HTML_HTML_TAG_NAME); 8425 setState(1015); 8426 _errHandler.sync(this); 8427 _la = _input.LA(1); 8428 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 8429 { 8430 { 8431 setState(1012); 8432 _la = _input.LA(1); 8433 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 8434 _errHandler.recoverInline(this); 8435 } else { 8436 consume(); 8437 } 8438 } 8439 } 8440 setState(1017); 8441 _errHandler.sync(this); 8442 _la = _input.LA(1); 8443 } 8444 setState(1018); 8445 match(CLOSE); 8446 } 8447 } 8448 catch (RecognitionException re) { 8449 _localctx.exception = re; 8450 _errHandler.reportError(this, re); 8451 _errHandler.recover(this, re); 8452 } 8453 finally { 8454 exitRule(); 8455 } 8456 return _localctx; 8457 } 8458 8459 public static class HtmlContext extends ParserRuleContext { 8460 public HtmlTagOpenContext htmlTagOpen() { 8461 return getRuleContext(HtmlTagOpenContext.class,0); 8462 } 8463 public HtmlTagCloseContext htmlTagClose() { 8464 return getRuleContext(HtmlTagCloseContext.class,0); 8465 } 8466 public List<HtmlTagContext> htmlTag() { 8467 return getRuleContexts(HtmlTagContext.class); 8468 } 8469 public HtmlTagContext htmlTag(int i) { 8470 return getRuleContext(HtmlTagContext.class,i); 8471 } 8472 public List<SingletonTagContext> singletonTag() { 8473 return getRuleContexts(SingletonTagContext.class); 8474 } 8475 public SingletonTagContext singletonTag(int i) { 8476 return getRuleContext(SingletonTagContext.class,i); 8477 } 8478 public List<ParagraphContext> paragraph() { 8479 return getRuleContexts(ParagraphContext.class); 8480 } 8481 public ParagraphContext paragraph(int i) { 8482 return getRuleContext(ParagraphContext.class,i); 8483 } 8484 public List<LiContext> li() { 8485 return getRuleContexts(LiContext.class); 8486 } 8487 public LiContext li(int i) { 8488 return getRuleContext(LiContext.class,i); 8489 } 8490 public List<TrContext> tr() { 8491 return getRuleContexts(TrContext.class); 8492 } 8493 public TrContext tr(int i) { 8494 return getRuleContext(TrContext.class,i); 8495 } 8496 public List<TdContext> td() { 8497 return getRuleContexts(TdContext.class); 8498 } 8499 public TdContext td(int i) { 8500 return getRuleContext(TdContext.class,i); 8501 } 8502 public List<ThContext> th() { 8503 return getRuleContexts(ThContext.class); 8504 } 8505 public ThContext th(int i) { 8506 return getRuleContext(ThContext.class,i); 8507 } 8508 public List<BodyContext> body() { 8509 return getRuleContexts(BodyContext.class); 8510 } 8511 public BodyContext body(int i) { 8512 return getRuleContext(BodyContext.class,i); 8513 } 8514 public List<ColgroupContext> colgroup() { 8515 return getRuleContexts(ColgroupContext.class); 8516 } 8517 public ColgroupContext colgroup(int i) { 8518 return getRuleContext(ColgroupContext.class,i); 8519 } 8520 public List<DdContext> dd() { 8521 return getRuleContexts(DdContext.class); 8522 } 8523 public DdContext dd(int i) { 8524 return getRuleContext(DdContext.class,i); 8525 } 8526 public List<DtContext> dt() { 8527 return getRuleContexts(DtContext.class); 8528 } 8529 public DtContext dt(int i) { 8530 return getRuleContext(DtContext.class,i); 8531 } 8532 public List<HeadContext> head() { 8533 return getRuleContexts(HeadContext.class); 8534 } 8535 public HeadContext head(int i) { 8536 return getRuleContext(HeadContext.class,i); 8537 } 8538 public List<OptionContext> option() { 8539 return getRuleContexts(OptionContext.class); 8540 } 8541 public OptionContext option(int i) { 8542 return getRuleContext(OptionContext.class,i); 8543 } 8544 public List<TbodyContext> tbody() { 8545 return getRuleContexts(TbodyContext.class); 8546 } 8547 public TbodyContext tbody(int i) { 8548 return getRuleContext(TbodyContext.class,i); 8549 } 8550 public List<TheadContext> thead() { 8551 return getRuleContexts(TheadContext.class); 8552 } 8553 public TheadContext thead(int i) { 8554 return getRuleContext(TheadContext.class,i); 8555 } 8556 public List<TfootContext> tfoot() { 8557 return getRuleContexts(TfootContext.class); 8558 } 8559 public TfootContext tfoot(int i) { 8560 return getRuleContext(TfootContext.class,i); 8561 } 8562 public List<PTagOpenContext> pTagOpen() { 8563 return getRuleContexts(PTagOpenContext.class); 8564 } 8565 public PTagOpenContext pTagOpen(int i) { 8566 return getRuleContext(PTagOpenContext.class,i); 8567 } 8568 public List<LiTagOpenContext> liTagOpen() { 8569 return getRuleContexts(LiTagOpenContext.class); 8570 } 8571 public LiTagOpenContext liTagOpen(int i) { 8572 return getRuleContext(LiTagOpenContext.class,i); 8573 } 8574 public List<TrTagOpenContext> trTagOpen() { 8575 return getRuleContexts(TrTagOpenContext.class); 8576 } 8577 public TrTagOpenContext trTagOpen(int i) { 8578 return getRuleContext(TrTagOpenContext.class,i); 8579 } 8580 public List<TdTagOpenContext> tdTagOpen() { 8581 return getRuleContexts(TdTagOpenContext.class); 8582 } 8583 public TdTagOpenContext tdTagOpen(int i) { 8584 return getRuleContext(TdTagOpenContext.class,i); 8585 } 8586 public List<ThTagOpenContext> thTagOpen() { 8587 return getRuleContexts(ThTagOpenContext.class); 8588 } 8589 public ThTagOpenContext thTagOpen(int i) { 8590 return getRuleContext(ThTagOpenContext.class,i); 8591 } 8592 public List<BodyTagOpenContext> bodyTagOpen() { 8593 return getRuleContexts(BodyTagOpenContext.class); 8594 } 8595 public BodyTagOpenContext bodyTagOpen(int i) { 8596 return getRuleContext(BodyTagOpenContext.class,i); 8597 } 8598 public List<ColgroupTagOpenContext> colgroupTagOpen() { 8599 return getRuleContexts(ColgroupTagOpenContext.class); 8600 } 8601 public ColgroupTagOpenContext colgroupTagOpen(int i) { 8602 return getRuleContext(ColgroupTagOpenContext.class,i); 8603 } 8604 public List<DdTagOpenContext> ddTagOpen() { 8605 return getRuleContexts(DdTagOpenContext.class); 8606 } 8607 public DdTagOpenContext ddTagOpen(int i) { 8608 return getRuleContext(DdTagOpenContext.class,i); 8609 } 8610 public List<DtTagOpenContext> dtTagOpen() { 8611 return getRuleContexts(DtTagOpenContext.class); 8612 } 8613 public DtTagOpenContext dtTagOpen(int i) { 8614 return getRuleContext(DtTagOpenContext.class,i); 8615 } 8616 public List<HeadTagOpenContext> headTagOpen() { 8617 return getRuleContexts(HeadTagOpenContext.class); 8618 } 8619 public HeadTagOpenContext headTagOpen(int i) { 8620 return getRuleContext(HeadTagOpenContext.class,i); 8621 } 8622 public List<OptionTagOpenContext> optionTagOpen() { 8623 return getRuleContexts(OptionTagOpenContext.class); 8624 } 8625 public OptionTagOpenContext optionTagOpen(int i) { 8626 return getRuleContext(OptionTagOpenContext.class,i); 8627 } 8628 public List<TbodyTagOpenContext> tbodyTagOpen() { 8629 return getRuleContexts(TbodyTagOpenContext.class); 8630 } 8631 public TbodyTagOpenContext tbodyTagOpen(int i) { 8632 return getRuleContext(TbodyTagOpenContext.class,i); 8633 } 8634 public List<TheadTagOpenContext> theadTagOpen() { 8635 return getRuleContexts(TheadTagOpenContext.class); 8636 } 8637 public TheadTagOpenContext theadTagOpen(int i) { 8638 return getRuleContext(TheadTagOpenContext.class,i); 8639 } 8640 public List<TfootTagOpenContext> tfootTagOpen() { 8641 return getRuleContexts(TfootTagOpenContext.class); 8642 } 8643 public TfootTagOpenContext tfootTagOpen(int i) { 8644 return getRuleContext(TfootTagOpenContext.class,i); 8645 } 8646 public List<HtmlCommentContext> htmlComment() { 8647 return getRuleContexts(HtmlCommentContext.class); 8648 } 8649 public HtmlCommentContext htmlComment(int i) { 8650 return getRuleContext(HtmlCommentContext.class,i); 8651 } 8652 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8653 public TerminalNode CDATA(int i) { 8654 return getToken(JavadocParser.CDATA, i); 8655 } 8656 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8657 public TerminalNode NEWLINE(int i) { 8658 return getToken(JavadocParser.NEWLINE, i); 8659 } 8660 public List<TextContext> text() { 8661 return getRuleContexts(TextContext.class); 8662 } 8663 public TextContext text(int i) { 8664 return getRuleContext(TextContext.class,i); 8665 } 8666 public List<JavadocInlineTagContext> javadocInlineTag() { 8667 return getRuleContexts(JavadocInlineTagContext.class); 8668 } 8669 public JavadocInlineTagContext javadocInlineTag(int i) { 8670 return getRuleContext(JavadocInlineTagContext.class,i); 8671 } 8672 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8673 public TerminalNode LEADING_ASTERISK(int i) { 8674 return getToken(JavadocParser.LEADING_ASTERISK, i); 8675 } 8676 public HtmlContext(ParserRuleContext parent, int invokingState) { 8677 super(parent, invokingState); 8678 } 8679 @Override public int getRuleIndex() { return RULE_html; } 8680 @Override 8681 public void enterRule(ParseTreeListener listener) { 8682 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtml(this); 8683 } 8684 @Override 8685 public void exitRule(ParseTreeListener listener) { 8686 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtml(this); 8687 } 8688 @Override 8689 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8690 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtml(this); 8691 else return visitor.visitChildren(this); 8692 } 8693 } 8694 8695 public final HtmlContext html() throws RecognitionException { 8696 HtmlContext _localctx = new HtmlContext(_ctx, getState()); 8697 enterRule(_localctx, 76, RULE_html); 8698 try { 8699 int _alt; 8700 enterOuterAlt(_localctx, 1); 8701 { 8702 setState(1020); 8703 htmlTagOpen(); 8704 setState(1060); 8705 _errHandler.sync(this); 8706 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 8707 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8708 if ( _alt==1 ) { 8709 { 8710 setState(1058); 8711 switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { 8712 case 1: 8713 { 8714 setState(1021); 8715 htmlTag(); 8716 } 8717 break; 8718 case 2: 8719 { 8720 setState(1022); 8721 singletonTag(); 8722 } 8723 break; 8724 case 3: 8725 { 8726 setState(1023); 8727 paragraph(); 8728 } 8729 break; 8730 case 4: 8731 { 8732 setState(1024); 8733 li(); 8734 } 8735 break; 8736 case 5: 8737 { 8738 setState(1025); 8739 tr(); 8740 } 8741 break; 8742 case 6: 8743 { 8744 setState(1026); 8745 td(); 8746 } 8747 break; 8748 case 7: 8749 { 8750 setState(1027); 8751 th(); 8752 } 8753 break; 8754 case 8: 8755 { 8756 setState(1028); 8757 body(); 8758 } 8759 break; 8760 case 9: 8761 { 8762 setState(1029); 8763 colgroup(); 8764 } 8765 break; 8766 case 10: 8767 { 8768 setState(1030); 8769 dd(); 8770 } 8771 break; 8772 case 11: 8773 { 8774 setState(1031); 8775 dt(); 8776 } 8777 break; 8778 case 12: 8779 { 8780 setState(1032); 8781 head(); 8782 } 8783 break; 8784 case 13: 8785 { 8786 setState(1033); 8787 option(); 8788 } 8789 break; 8790 case 14: 8791 { 8792 setState(1034); 8793 tbody(); 8794 } 8795 break; 8796 case 15: 8797 { 8798 setState(1035); 8799 thead(); 8800 } 8801 break; 8802 case 16: 8803 { 8804 setState(1036); 8805 tfoot(); 8806 } 8807 break; 8808 case 17: 8809 { 8810 setState(1037); 8811 pTagOpen(); 8812 } 8813 break; 8814 case 18: 8815 { 8816 setState(1038); 8817 liTagOpen(); 8818 } 8819 break; 8820 case 19: 8821 { 8822 setState(1039); 8823 trTagOpen(); 8824 } 8825 break; 8826 case 20: 8827 { 8828 setState(1040); 8829 tdTagOpen(); 8830 } 8831 break; 8832 case 21: 8833 { 8834 setState(1041); 8835 thTagOpen(); 8836 } 8837 break; 8838 case 22: 8839 { 8840 setState(1042); 8841 bodyTagOpen(); 8842 } 8843 break; 8844 case 23: 8845 { 8846 setState(1043); 8847 colgroupTagOpen(); 8848 } 8849 break; 8850 case 24: 8851 { 8852 setState(1044); 8853 ddTagOpen(); 8854 } 8855 break; 8856 case 25: 8857 { 8858 setState(1045); 8859 dtTagOpen(); 8860 } 8861 break; 8862 case 26: 8863 { 8864 setState(1046); 8865 headTagOpen(); 8866 } 8867 break; 8868 case 27: 8869 { 8870 setState(1047); 8871 optionTagOpen(); 8872 } 8873 break; 8874 case 28: 8875 { 8876 setState(1048); 8877 tbodyTagOpen(); 8878 } 8879 break; 8880 case 29: 8881 { 8882 setState(1049); 8883 theadTagOpen(); 8884 } 8885 break; 8886 case 30: 8887 { 8888 setState(1050); 8889 tfootTagOpen(); 8890 } 8891 break; 8892 case 31: 8893 { 8894 { 8895 setState(1051); 8896 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8897 setState(1052); 8898 match(LEADING_ASTERISK); 8899 } 8900 } 8901 break; 8902 case 32: 8903 { 8904 setState(1053); 8905 htmlComment(); 8906 } 8907 break; 8908 case 33: 8909 { 8910 setState(1054); 8911 match(CDATA); 8912 } 8913 break; 8914 case 34: 8915 { 8916 setState(1055); 8917 match(NEWLINE); 8918 } 8919 break; 8920 case 35: 8921 { 8922 setState(1056); 8923 text(); 8924 } 8925 break; 8926 case 36: 8927 { 8928 setState(1057); 8929 javadocInlineTag(); 8930 } 8931 break; 8932 } 8933 } 8934 } 8935 setState(1062); 8936 _errHandler.sync(this); 8937 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 8938 } 8939 setState(1063); 8940 htmlTagClose(); 8941 } 8942 } 8943 catch (RecognitionException re) { 8944 _localctx.exception = re; 8945 _errHandler.reportError(this, re); 8946 _errHandler.recover(this, re); 8947 } 8948 finally { 8949 exitRule(); 8950 } 8951 return _localctx; 8952 } 8953 8954 public static class OptionTagOpenContext extends ParserRuleContext { 8955 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8956 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 8957 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8958 public List<AttributeContext> attribute() { 8959 return getRuleContexts(AttributeContext.class); 8960 } 8961 public AttributeContext attribute(int i) { 8962 return getRuleContext(AttributeContext.class,i); 8963 } 8964 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8965 public TerminalNode NEWLINE(int i) { 8966 return getToken(JavadocParser.NEWLINE, i); 8967 } 8968 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8969 public TerminalNode LEADING_ASTERISK(int i) { 8970 return getToken(JavadocParser.LEADING_ASTERISK, i); 8971 } 8972 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8973 public TerminalNode WS(int i) { 8974 return getToken(JavadocParser.WS, i); 8975 } 8976 public OptionTagOpenContext(ParserRuleContext parent, int invokingState) { 8977 super(parent, invokingState); 8978 } 8979 @Override public int getRuleIndex() { return RULE_optionTagOpen; } 8980 @Override 8981 public void enterRule(ParseTreeListener listener) { 8982 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagOpen(this); 8983 } 8984 @Override 8985 public void exitRule(ParseTreeListener listener) { 8986 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagOpen(this); 8987 } 8988 @Override 8989 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8990 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagOpen(this); 8991 else return visitor.visitChildren(this); 8992 } 8993 } 8994 8995 public final OptionTagOpenContext optionTagOpen() throws RecognitionException { 8996 OptionTagOpenContext _localctx = new OptionTagOpenContext(_ctx, getState()); 8997 enterRule(_localctx, 78, RULE_optionTagOpen); 8998 int _la; 8999 try { 9000 enterOuterAlt(_localctx, 1); 9001 { 9002 setState(1065); 9003 match(OPEN); 9004 setState(1066); 9005 match(OPTION_HTML_TAG_NAME); 9006 setState(1073); 9007 _errHandler.sync(this); 9008 _la = _input.LA(1); 9009 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9010 { 9011 setState(1071); 9012 switch (_input.LA(1)) { 9013 case HTML_TAG_NAME: 9014 { 9015 setState(1067); 9016 attribute(); 9017 } 9018 break; 9019 case NEWLINE: 9020 { 9021 setState(1068); 9022 match(NEWLINE); 9023 } 9024 break; 9025 case LEADING_ASTERISK: 9026 { 9027 setState(1069); 9028 match(LEADING_ASTERISK); 9029 } 9030 break; 9031 case WS: 9032 { 9033 setState(1070); 9034 match(WS); 9035 } 9036 break; 9037 default: 9038 throw new NoViableAltException(this); 9039 } 9040 } 9041 setState(1075); 9042 _errHandler.sync(this); 9043 _la = _input.LA(1); 9044 } 9045 setState(1076); 9046 match(CLOSE); 9047 } 9048 } 9049 catch (RecognitionException re) { 9050 _localctx.exception = re; 9051 _errHandler.reportError(this, re); 9052 _errHandler.recover(this, re); 9053 } 9054 finally { 9055 exitRule(); 9056 } 9057 return _localctx; 9058 } 9059 9060 public static class OptionTagCloseContext extends ParserRuleContext { 9061 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9062 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9063 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 9064 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9065 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9066 public TerminalNode NEWLINE(int i) { 9067 return getToken(JavadocParser.NEWLINE, i); 9068 } 9069 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9070 public TerminalNode LEADING_ASTERISK(int i) { 9071 return getToken(JavadocParser.LEADING_ASTERISK, i); 9072 } 9073 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9074 public TerminalNode WS(int i) { 9075 return getToken(JavadocParser.WS, i); 9076 } 9077 public OptionTagCloseContext(ParserRuleContext parent, int invokingState) { 9078 super(parent, invokingState); 9079 } 9080 @Override public int getRuleIndex() { return RULE_optionTagClose; } 9081 @Override 9082 public void enterRule(ParseTreeListener listener) { 9083 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagClose(this); 9084 } 9085 @Override 9086 public void exitRule(ParseTreeListener listener) { 9087 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagClose(this); 9088 } 9089 @Override 9090 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9091 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagClose(this); 9092 else return visitor.visitChildren(this); 9093 } 9094 } 9095 9096 public final OptionTagCloseContext optionTagClose() throws RecognitionException { 9097 OptionTagCloseContext _localctx = new OptionTagCloseContext(_ctx, getState()); 9098 enterRule(_localctx, 80, RULE_optionTagClose); 9099 int _la; 9100 try { 9101 enterOuterAlt(_localctx, 1); 9102 { 9103 setState(1078); 9104 match(OPEN); 9105 setState(1079); 9106 match(SLASH); 9107 setState(1080); 9108 match(OPTION_HTML_TAG_NAME); 9109 setState(1084); 9110 _errHandler.sync(this); 9111 _la = _input.LA(1); 9112 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9113 { 9114 { 9115 setState(1081); 9116 _la = _input.LA(1); 9117 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9118 _errHandler.recoverInline(this); 9119 } else { 9120 consume(); 9121 } 9122 } 9123 } 9124 setState(1086); 9125 _errHandler.sync(this); 9126 _la = _input.LA(1); 9127 } 9128 setState(1087); 9129 match(CLOSE); 9130 } 9131 } 9132 catch (RecognitionException re) { 9133 _localctx.exception = re; 9134 _errHandler.reportError(this, re); 9135 _errHandler.recover(this, re); 9136 } 9137 finally { 9138 exitRule(); 9139 } 9140 return _localctx; 9141 } 9142 9143 public static class OptionContext extends ParserRuleContext { 9144 public OptionTagOpenContext optionTagOpen() { 9145 return getRuleContext(OptionTagOpenContext.class,0); 9146 } 9147 public OptionTagCloseContext optionTagClose() { 9148 return getRuleContext(OptionTagCloseContext.class,0); 9149 } 9150 public List<HtmlTagContext> htmlTag() { 9151 return getRuleContexts(HtmlTagContext.class); 9152 } 9153 public HtmlTagContext htmlTag(int i) { 9154 return getRuleContext(HtmlTagContext.class,i); 9155 } 9156 public List<SingletonTagContext> singletonTag() { 9157 return getRuleContexts(SingletonTagContext.class); 9158 } 9159 public SingletonTagContext singletonTag(int i) { 9160 return getRuleContext(SingletonTagContext.class,i); 9161 } 9162 public List<ParagraphContext> paragraph() { 9163 return getRuleContexts(ParagraphContext.class); 9164 } 9165 public ParagraphContext paragraph(int i) { 9166 return getRuleContext(ParagraphContext.class,i); 9167 } 9168 public List<LiContext> li() { 9169 return getRuleContexts(LiContext.class); 9170 } 9171 public LiContext li(int i) { 9172 return getRuleContext(LiContext.class,i); 9173 } 9174 public List<TrContext> tr() { 9175 return getRuleContexts(TrContext.class); 9176 } 9177 public TrContext tr(int i) { 9178 return getRuleContext(TrContext.class,i); 9179 } 9180 public List<TdContext> td() { 9181 return getRuleContexts(TdContext.class); 9182 } 9183 public TdContext td(int i) { 9184 return getRuleContext(TdContext.class,i); 9185 } 9186 public List<ThContext> th() { 9187 return getRuleContexts(ThContext.class); 9188 } 9189 public ThContext th(int i) { 9190 return getRuleContext(ThContext.class,i); 9191 } 9192 public List<BodyContext> body() { 9193 return getRuleContexts(BodyContext.class); 9194 } 9195 public BodyContext body(int i) { 9196 return getRuleContext(BodyContext.class,i); 9197 } 9198 public List<ColgroupContext> colgroup() { 9199 return getRuleContexts(ColgroupContext.class); 9200 } 9201 public ColgroupContext colgroup(int i) { 9202 return getRuleContext(ColgroupContext.class,i); 9203 } 9204 public List<DdContext> dd() { 9205 return getRuleContexts(DdContext.class); 9206 } 9207 public DdContext dd(int i) { 9208 return getRuleContext(DdContext.class,i); 9209 } 9210 public List<DtContext> dt() { 9211 return getRuleContexts(DtContext.class); 9212 } 9213 public DtContext dt(int i) { 9214 return getRuleContext(DtContext.class,i); 9215 } 9216 public List<HeadContext> head() { 9217 return getRuleContexts(HeadContext.class); 9218 } 9219 public HeadContext head(int i) { 9220 return getRuleContext(HeadContext.class,i); 9221 } 9222 public List<HtmlContext> html() { 9223 return getRuleContexts(HtmlContext.class); 9224 } 9225 public HtmlContext html(int i) { 9226 return getRuleContext(HtmlContext.class,i); 9227 } 9228 public List<TbodyContext> tbody() { 9229 return getRuleContexts(TbodyContext.class); 9230 } 9231 public TbodyContext tbody(int i) { 9232 return getRuleContext(TbodyContext.class,i); 9233 } 9234 public List<TheadContext> thead() { 9235 return getRuleContexts(TheadContext.class); 9236 } 9237 public TheadContext thead(int i) { 9238 return getRuleContext(TheadContext.class,i); 9239 } 9240 public List<TfootContext> tfoot() { 9241 return getRuleContexts(TfootContext.class); 9242 } 9243 public TfootContext tfoot(int i) { 9244 return getRuleContext(TfootContext.class,i); 9245 } 9246 public List<PTagOpenContext> pTagOpen() { 9247 return getRuleContexts(PTagOpenContext.class); 9248 } 9249 public PTagOpenContext pTagOpen(int i) { 9250 return getRuleContext(PTagOpenContext.class,i); 9251 } 9252 public List<LiTagOpenContext> liTagOpen() { 9253 return getRuleContexts(LiTagOpenContext.class); 9254 } 9255 public LiTagOpenContext liTagOpen(int i) { 9256 return getRuleContext(LiTagOpenContext.class,i); 9257 } 9258 public List<TrTagOpenContext> trTagOpen() { 9259 return getRuleContexts(TrTagOpenContext.class); 9260 } 9261 public TrTagOpenContext trTagOpen(int i) { 9262 return getRuleContext(TrTagOpenContext.class,i); 9263 } 9264 public List<TdTagOpenContext> tdTagOpen() { 9265 return getRuleContexts(TdTagOpenContext.class); 9266 } 9267 public TdTagOpenContext tdTagOpen(int i) { 9268 return getRuleContext(TdTagOpenContext.class,i); 9269 } 9270 public List<ThTagOpenContext> thTagOpen() { 9271 return getRuleContexts(ThTagOpenContext.class); 9272 } 9273 public ThTagOpenContext thTagOpen(int i) { 9274 return getRuleContext(ThTagOpenContext.class,i); 9275 } 9276 public List<BodyTagOpenContext> bodyTagOpen() { 9277 return getRuleContexts(BodyTagOpenContext.class); 9278 } 9279 public BodyTagOpenContext bodyTagOpen(int i) { 9280 return getRuleContext(BodyTagOpenContext.class,i); 9281 } 9282 public List<ColgroupTagOpenContext> colgroupTagOpen() { 9283 return getRuleContexts(ColgroupTagOpenContext.class); 9284 } 9285 public ColgroupTagOpenContext colgroupTagOpen(int i) { 9286 return getRuleContext(ColgroupTagOpenContext.class,i); 9287 } 9288 public List<DdTagOpenContext> ddTagOpen() { 9289 return getRuleContexts(DdTagOpenContext.class); 9290 } 9291 public DdTagOpenContext ddTagOpen(int i) { 9292 return getRuleContext(DdTagOpenContext.class,i); 9293 } 9294 public List<DtTagOpenContext> dtTagOpen() { 9295 return getRuleContexts(DtTagOpenContext.class); 9296 } 9297 public DtTagOpenContext dtTagOpen(int i) { 9298 return getRuleContext(DtTagOpenContext.class,i); 9299 } 9300 public List<HeadTagOpenContext> headTagOpen() { 9301 return getRuleContexts(HeadTagOpenContext.class); 9302 } 9303 public HeadTagOpenContext headTagOpen(int i) { 9304 return getRuleContext(HeadTagOpenContext.class,i); 9305 } 9306 public List<HtmlTagOpenContext> htmlTagOpen() { 9307 return getRuleContexts(HtmlTagOpenContext.class); 9308 } 9309 public HtmlTagOpenContext htmlTagOpen(int i) { 9310 return getRuleContext(HtmlTagOpenContext.class,i); 9311 } 9312 public List<TbodyTagOpenContext> tbodyTagOpen() { 9313 return getRuleContexts(TbodyTagOpenContext.class); 9314 } 9315 public TbodyTagOpenContext tbodyTagOpen(int i) { 9316 return getRuleContext(TbodyTagOpenContext.class,i); 9317 } 9318 public List<TheadTagOpenContext> theadTagOpen() { 9319 return getRuleContexts(TheadTagOpenContext.class); 9320 } 9321 public TheadTagOpenContext theadTagOpen(int i) { 9322 return getRuleContext(TheadTagOpenContext.class,i); 9323 } 9324 public List<TfootTagOpenContext> tfootTagOpen() { 9325 return getRuleContexts(TfootTagOpenContext.class); 9326 } 9327 public TfootTagOpenContext tfootTagOpen(int i) { 9328 return getRuleContext(TfootTagOpenContext.class,i); 9329 } 9330 public List<HtmlCommentContext> htmlComment() { 9331 return getRuleContexts(HtmlCommentContext.class); 9332 } 9333 public HtmlCommentContext htmlComment(int i) { 9334 return getRuleContext(HtmlCommentContext.class,i); 9335 } 9336 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 9337 public TerminalNode CDATA(int i) { 9338 return getToken(JavadocParser.CDATA, i); 9339 } 9340 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9341 public TerminalNode NEWLINE(int i) { 9342 return getToken(JavadocParser.NEWLINE, i); 9343 } 9344 public List<TextContext> text() { 9345 return getRuleContexts(TextContext.class); 9346 } 9347 public TextContext text(int i) { 9348 return getRuleContext(TextContext.class,i); 9349 } 9350 public List<JavadocInlineTagContext> javadocInlineTag() { 9351 return getRuleContexts(JavadocInlineTagContext.class); 9352 } 9353 public JavadocInlineTagContext javadocInlineTag(int i) { 9354 return getRuleContext(JavadocInlineTagContext.class,i); 9355 } 9356 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9357 public TerminalNode LEADING_ASTERISK(int i) { 9358 return getToken(JavadocParser.LEADING_ASTERISK, i); 9359 } 9360 public OptionContext(ParserRuleContext parent, int invokingState) { 9361 super(parent, invokingState); 9362 } 9363 @Override public int getRuleIndex() { return RULE_option; } 9364 @Override 9365 public void enterRule(ParseTreeListener listener) { 9366 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOption(this); 9367 } 9368 @Override 9369 public void exitRule(ParseTreeListener listener) { 9370 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOption(this); 9371 } 9372 @Override 9373 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9374 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOption(this); 9375 else return visitor.visitChildren(this); 9376 } 9377 } 9378 9379 public final OptionContext option() throws RecognitionException { 9380 OptionContext _localctx = new OptionContext(_ctx, getState()); 9381 enterRule(_localctx, 82, RULE_option); 9382 try { 9383 int _alt; 9384 enterOuterAlt(_localctx, 1); 9385 { 9386 setState(1089); 9387 optionTagOpen(); 9388 setState(1129); 9389 _errHandler.sync(this); 9390 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 9391 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 9392 if ( _alt==1 ) { 9393 { 9394 setState(1127); 9395 switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { 9396 case 1: 9397 { 9398 setState(1090); 9399 htmlTag(); 9400 } 9401 break; 9402 case 2: 9403 { 9404 setState(1091); 9405 singletonTag(); 9406 } 9407 break; 9408 case 3: 9409 { 9410 setState(1092); 9411 paragraph(); 9412 } 9413 break; 9414 case 4: 9415 { 9416 setState(1093); 9417 li(); 9418 } 9419 break; 9420 case 5: 9421 { 9422 setState(1094); 9423 tr(); 9424 } 9425 break; 9426 case 6: 9427 { 9428 setState(1095); 9429 td(); 9430 } 9431 break; 9432 case 7: 9433 { 9434 setState(1096); 9435 th(); 9436 } 9437 break; 9438 case 8: 9439 { 9440 setState(1097); 9441 body(); 9442 } 9443 break; 9444 case 9: 9445 { 9446 setState(1098); 9447 colgroup(); 9448 } 9449 break; 9450 case 10: 9451 { 9452 setState(1099); 9453 dd(); 9454 } 9455 break; 9456 case 11: 9457 { 9458 setState(1100); 9459 dt(); 9460 } 9461 break; 9462 case 12: 9463 { 9464 setState(1101); 9465 head(); 9466 } 9467 break; 9468 case 13: 9469 { 9470 setState(1102); 9471 html(); 9472 } 9473 break; 9474 case 14: 9475 { 9476 setState(1103); 9477 tbody(); 9478 } 9479 break; 9480 case 15: 9481 { 9482 setState(1104); 9483 thead(); 9484 } 9485 break; 9486 case 16: 9487 { 9488 setState(1105); 9489 tfoot(); 9490 } 9491 break; 9492 case 17: 9493 { 9494 setState(1106); 9495 pTagOpen(); 9496 } 9497 break; 9498 case 18: 9499 { 9500 setState(1107); 9501 liTagOpen(); 9502 } 9503 break; 9504 case 19: 9505 { 9506 setState(1108); 9507 trTagOpen(); 9508 } 9509 break; 9510 case 20: 9511 { 9512 setState(1109); 9513 tdTagOpen(); 9514 } 9515 break; 9516 case 21: 9517 { 9518 setState(1110); 9519 thTagOpen(); 9520 } 9521 break; 9522 case 22: 9523 { 9524 setState(1111); 9525 bodyTagOpen(); 9526 } 9527 break; 9528 case 23: 9529 { 9530 setState(1112); 9531 colgroupTagOpen(); 9532 } 9533 break; 9534 case 24: 9535 { 9536 setState(1113); 9537 ddTagOpen(); 9538 } 9539 break; 9540 case 25: 9541 { 9542 setState(1114); 9543 dtTagOpen(); 9544 } 9545 break; 9546 case 26: 9547 { 9548 setState(1115); 9549 headTagOpen(); 9550 } 9551 break; 9552 case 27: 9553 { 9554 setState(1116); 9555 htmlTagOpen(); 9556 } 9557 break; 9558 case 28: 9559 { 9560 setState(1117); 9561 tbodyTagOpen(); 9562 } 9563 break; 9564 case 29: 9565 { 9566 setState(1118); 9567 theadTagOpen(); 9568 } 9569 break; 9570 case 30: 9571 { 9572 setState(1119); 9573 tfootTagOpen(); 9574 } 9575 break; 9576 case 31: 9577 { 9578 { 9579 setState(1120); 9580 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 9581 setState(1121); 9582 match(LEADING_ASTERISK); 9583 } 9584 } 9585 break; 9586 case 32: 9587 { 9588 setState(1122); 9589 htmlComment(); 9590 } 9591 break; 9592 case 33: 9593 { 9594 setState(1123); 9595 match(CDATA); 9596 } 9597 break; 9598 case 34: 9599 { 9600 setState(1124); 9601 match(NEWLINE); 9602 } 9603 break; 9604 case 35: 9605 { 9606 setState(1125); 9607 text(); 9608 } 9609 break; 9610 case 36: 9611 { 9612 setState(1126); 9613 javadocInlineTag(); 9614 } 9615 break; 9616 } 9617 } 9618 } 9619 setState(1131); 9620 _errHandler.sync(this); 9621 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 9622 } 9623 setState(1132); 9624 optionTagClose(); 9625 } 9626 } 9627 catch (RecognitionException re) { 9628 _localctx.exception = re; 9629 _errHandler.reportError(this, re); 9630 _errHandler.recover(this, re); 9631 } 9632 finally { 9633 exitRule(); 9634 } 9635 return _localctx; 9636 } 9637 9638 public static class TbodyTagOpenContext extends ParserRuleContext { 9639 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9640 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9641 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9642 public List<AttributeContext> attribute() { 9643 return getRuleContexts(AttributeContext.class); 9644 } 9645 public AttributeContext attribute(int i) { 9646 return getRuleContext(AttributeContext.class,i); 9647 } 9648 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9649 public TerminalNode NEWLINE(int i) { 9650 return getToken(JavadocParser.NEWLINE, i); 9651 } 9652 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9653 public TerminalNode LEADING_ASTERISK(int i) { 9654 return getToken(JavadocParser.LEADING_ASTERISK, i); 9655 } 9656 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9657 public TerminalNode WS(int i) { 9658 return getToken(JavadocParser.WS, i); 9659 } 9660 public TbodyTagOpenContext(ParserRuleContext parent, int invokingState) { 9661 super(parent, invokingState); 9662 } 9663 @Override public int getRuleIndex() { return RULE_tbodyTagOpen; } 9664 @Override 9665 public void enterRule(ParseTreeListener listener) { 9666 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagOpen(this); 9667 } 9668 @Override 9669 public void exitRule(ParseTreeListener listener) { 9670 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagOpen(this); 9671 } 9672 @Override 9673 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9674 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagOpen(this); 9675 else return visitor.visitChildren(this); 9676 } 9677 } 9678 9679 public final TbodyTagOpenContext tbodyTagOpen() throws RecognitionException { 9680 TbodyTagOpenContext _localctx = new TbodyTagOpenContext(_ctx, getState()); 9681 enterRule(_localctx, 84, RULE_tbodyTagOpen); 9682 int _la; 9683 try { 9684 enterOuterAlt(_localctx, 1); 9685 { 9686 setState(1134); 9687 match(OPEN); 9688 setState(1135); 9689 match(TBODY_HTML_TAG_NAME); 9690 setState(1142); 9691 _errHandler.sync(this); 9692 _la = _input.LA(1); 9693 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9694 { 9695 setState(1140); 9696 switch (_input.LA(1)) { 9697 case HTML_TAG_NAME: 9698 { 9699 setState(1136); 9700 attribute(); 9701 } 9702 break; 9703 case NEWLINE: 9704 { 9705 setState(1137); 9706 match(NEWLINE); 9707 } 9708 break; 9709 case LEADING_ASTERISK: 9710 { 9711 setState(1138); 9712 match(LEADING_ASTERISK); 9713 } 9714 break; 9715 case WS: 9716 { 9717 setState(1139); 9718 match(WS); 9719 } 9720 break; 9721 default: 9722 throw new NoViableAltException(this); 9723 } 9724 } 9725 setState(1144); 9726 _errHandler.sync(this); 9727 _la = _input.LA(1); 9728 } 9729 setState(1145); 9730 match(CLOSE); 9731 } 9732 } 9733 catch (RecognitionException re) { 9734 _localctx.exception = re; 9735 _errHandler.reportError(this, re); 9736 _errHandler.recover(this, re); 9737 } 9738 finally { 9739 exitRule(); 9740 } 9741 return _localctx; 9742 } 9743 9744 public static class TbodyTagCloseContext extends ParserRuleContext { 9745 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9746 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9747 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9748 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9749 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9750 public TerminalNode NEWLINE(int i) { 9751 return getToken(JavadocParser.NEWLINE, i); 9752 } 9753 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9754 public TerminalNode LEADING_ASTERISK(int i) { 9755 return getToken(JavadocParser.LEADING_ASTERISK, i); 9756 } 9757 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9758 public TerminalNode WS(int i) { 9759 return getToken(JavadocParser.WS, i); 9760 } 9761 public TbodyTagCloseContext(ParserRuleContext parent, int invokingState) { 9762 super(parent, invokingState); 9763 } 9764 @Override public int getRuleIndex() { return RULE_tbodyTagClose; } 9765 @Override 9766 public void enterRule(ParseTreeListener listener) { 9767 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagClose(this); 9768 } 9769 @Override 9770 public void exitRule(ParseTreeListener listener) { 9771 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagClose(this); 9772 } 9773 @Override 9774 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9775 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagClose(this); 9776 else return visitor.visitChildren(this); 9777 } 9778 } 9779 9780 public final TbodyTagCloseContext tbodyTagClose() throws RecognitionException { 9781 TbodyTagCloseContext _localctx = new TbodyTagCloseContext(_ctx, getState()); 9782 enterRule(_localctx, 86, RULE_tbodyTagClose); 9783 int _la; 9784 try { 9785 enterOuterAlt(_localctx, 1); 9786 { 9787 setState(1147); 9788 match(OPEN); 9789 setState(1148); 9790 match(SLASH); 9791 setState(1149); 9792 match(TBODY_HTML_TAG_NAME); 9793 setState(1153); 9794 _errHandler.sync(this); 9795 _la = _input.LA(1); 9796 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9797 { 9798 { 9799 setState(1150); 9800 _la = _input.LA(1); 9801 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9802 _errHandler.recoverInline(this); 9803 } else { 9804 consume(); 9805 } 9806 } 9807 } 9808 setState(1155); 9809 _errHandler.sync(this); 9810 _la = _input.LA(1); 9811 } 9812 setState(1156); 9813 match(CLOSE); 9814 } 9815 } 9816 catch (RecognitionException re) { 9817 _localctx.exception = re; 9818 _errHandler.reportError(this, re); 9819 _errHandler.recover(this, re); 9820 } 9821 finally { 9822 exitRule(); 9823 } 9824 return _localctx; 9825 } 9826 9827 public static class TbodyContext extends ParserRuleContext { 9828 public TbodyTagOpenContext tbodyTagOpen() { 9829 return getRuleContext(TbodyTagOpenContext.class,0); 9830 } 9831 public TbodyTagCloseContext tbodyTagClose() { 9832 return getRuleContext(TbodyTagCloseContext.class,0); 9833 } 9834 public List<HtmlTagContext> htmlTag() { 9835 return getRuleContexts(HtmlTagContext.class); 9836 } 9837 public HtmlTagContext htmlTag(int i) { 9838 return getRuleContext(HtmlTagContext.class,i); 9839 } 9840 public List<SingletonTagContext> singletonTag() { 9841 return getRuleContexts(SingletonTagContext.class); 9842 } 9843 public SingletonTagContext singletonTag(int i) { 9844 return getRuleContext(SingletonTagContext.class,i); 9845 } 9846 public List<ParagraphContext> paragraph() { 9847 return getRuleContexts(ParagraphContext.class); 9848 } 9849 public ParagraphContext paragraph(int i) { 9850 return getRuleContext(ParagraphContext.class,i); 9851 } 9852 public List<LiContext> li() { 9853 return getRuleContexts(LiContext.class); 9854 } 9855 public LiContext li(int i) { 9856 return getRuleContext(LiContext.class,i); 9857 } 9858 public List<TrContext> tr() { 9859 return getRuleContexts(TrContext.class); 9860 } 9861 public TrContext tr(int i) { 9862 return getRuleContext(TrContext.class,i); 9863 } 9864 public List<TdContext> td() { 9865 return getRuleContexts(TdContext.class); 9866 } 9867 public TdContext td(int i) { 9868 return getRuleContext(TdContext.class,i); 9869 } 9870 public List<ThContext> th() { 9871 return getRuleContexts(ThContext.class); 9872 } 9873 public ThContext th(int i) { 9874 return getRuleContext(ThContext.class,i); 9875 } 9876 public List<BodyContext> body() { 9877 return getRuleContexts(BodyContext.class); 9878 } 9879 public BodyContext body(int i) { 9880 return getRuleContext(BodyContext.class,i); 9881 } 9882 public List<ColgroupContext> colgroup() { 9883 return getRuleContexts(ColgroupContext.class); 9884 } 9885 public ColgroupContext colgroup(int i) { 9886 return getRuleContext(ColgroupContext.class,i); 9887 } 9888 public List<DdContext> dd() { 9889 return getRuleContexts(DdContext.class); 9890 } 9891 public DdContext dd(int i) { 9892 return getRuleContext(DdContext.class,i); 9893 } 9894 public List<DtContext> dt() { 9895 return getRuleContexts(DtContext.class); 9896 } 9897 public DtContext dt(int i) { 9898 return getRuleContext(DtContext.class,i); 9899 } 9900 public List<HeadContext> head() { 9901 return getRuleContexts(HeadContext.class); 9902 } 9903 public HeadContext head(int i) { 9904 return getRuleContext(HeadContext.class,i); 9905 } 9906 public List<HtmlContext> html() { 9907 return getRuleContexts(HtmlContext.class); 9908 } 9909 public HtmlContext html(int i) { 9910 return getRuleContext(HtmlContext.class,i); 9911 } 9912 public List<OptionContext> option() { 9913 return getRuleContexts(OptionContext.class); 9914 } 9915 public OptionContext option(int i) { 9916 return getRuleContext(OptionContext.class,i); 9917 } 9918 public List<TheadContext> thead() { 9919 return getRuleContexts(TheadContext.class); 9920 } 9921 public TheadContext thead(int i) { 9922 return getRuleContext(TheadContext.class,i); 9923 } 9924 public List<TfootContext> tfoot() { 9925 return getRuleContexts(TfootContext.class); 9926 } 9927 public TfootContext tfoot(int i) { 9928 return getRuleContext(TfootContext.class,i); 9929 } 9930 public List<PTagOpenContext> pTagOpen() { 9931 return getRuleContexts(PTagOpenContext.class); 9932 } 9933 public PTagOpenContext pTagOpen(int i) { 9934 return getRuleContext(PTagOpenContext.class,i); 9935 } 9936 public List<LiTagOpenContext> liTagOpen() { 9937 return getRuleContexts(LiTagOpenContext.class); 9938 } 9939 public LiTagOpenContext liTagOpen(int i) { 9940 return getRuleContext(LiTagOpenContext.class,i); 9941 } 9942 public List<TrTagOpenContext> trTagOpen() { 9943 return getRuleContexts(TrTagOpenContext.class); 9944 } 9945 public TrTagOpenContext trTagOpen(int i) { 9946 return getRuleContext(TrTagOpenContext.class,i); 9947 } 9948 public List<TdTagOpenContext> tdTagOpen() { 9949 return getRuleContexts(TdTagOpenContext.class); 9950 } 9951 public TdTagOpenContext tdTagOpen(int i) { 9952 return getRuleContext(TdTagOpenContext.class,i); 9953 } 9954 public List<ThTagOpenContext> thTagOpen() { 9955 return getRuleContexts(ThTagOpenContext.class); 9956 } 9957 public ThTagOpenContext thTagOpen(int i) { 9958 return getRuleContext(ThTagOpenContext.class,i); 9959 } 9960 public List<BodyTagOpenContext> bodyTagOpen() { 9961 return getRuleContexts(BodyTagOpenContext.class); 9962 } 9963 public BodyTagOpenContext bodyTagOpen(int i) { 9964 return getRuleContext(BodyTagOpenContext.class,i); 9965 } 9966 public List<ColgroupTagOpenContext> colgroupTagOpen() { 9967 return getRuleContexts(ColgroupTagOpenContext.class); 9968 } 9969 public ColgroupTagOpenContext colgroupTagOpen(int i) { 9970 return getRuleContext(ColgroupTagOpenContext.class,i); 9971 } 9972 public List<DdTagOpenContext> ddTagOpen() { 9973 return getRuleContexts(DdTagOpenContext.class); 9974 } 9975 public DdTagOpenContext ddTagOpen(int i) { 9976 return getRuleContext(DdTagOpenContext.class,i); 9977 } 9978 public List<DtTagOpenContext> dtTagOpen() { 9979 return getRuleContexts(DtTagOpenContext.class); 9980 } 9981 public DtTagOpenContext dtTagOpen(int i) { 9982 return getRuleContext(DtTagOpenContext.class,i); 9983 } 9984 public List<HeadTagOpenContext> headTagOpen() { 9985 return getRuleContexts(HeadTagOpenContext.class); 9986 } 9987 public HeadTagOpenContext headTagOpen(int i) { 9988 return getRuleContext(HeadTagOpenContext.class,i); 9989 } 9990 public List<HtmlTagOpenContext> htmlTagOpen() { 9991 return getRuleContexts(HtmlTagOpenContext.class); 9992 } 9993 public HtmlTagOpenContext htmlTagOpen(int i) { 9994 return getRuleContext(HtmlTagOpenContext.class,i); 9995 } 9996 public List<OptionTagOpenContext> optionTagOpen() { 9997 return getRuleContexts(OptionTagOpenContext.class); 9998 } 9999 public OptionTagOpenContext optionTagOpen(int i) { 10000 return getRuleContext(OptionTagOpenContext.class,i); 10001 } 10002 public List<TheadTagOpenContext> theadTagOpen() { 10003 return getRuleContexts(TheadTagOpenContext.class); 10004 } 10005 public TheadTagOpenContext theadTagOpen(int i) { 10006 return getRuleContext(TheadTagOpenContext.class,i); 10007 } 10008 public List<TfootTagOpenContext> tfootTagOpen() { 10009 return getRuleContexts(TfootTagOpenContext.class); 10010 } 10011 public TfootTagOpenContext tfootTagOpen(int i) { 10012 return getRuleContext(TfootTagOpenContext.class,i); 10013 } 10014 public List<HtmlCommentContext> htmlComment() { 10015 return getRuleContexts(HtmlCommentContext.class); 10016 } 10017 public HtmlCommentContext htmlComment(int i) { 10018 return getRuleContext(HtmlCommentContext.class,i); 10019 } 10020 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10021 public TerminalNode CDATA(int i) { 10022 return getToken(JavadocParser.CDATA, i); 10023 } 10024 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10025 public TerminalNode NEWLINE(int i) { 10026 return getToken(JavadocParser.NEWLINE, i); 10027 } 10028 public List<TextContext> text() { 10029 return getRuleContexts(TextContext.class); 10030 } 10031 public TextContext text(int i) { 10032 return getRuleContext(TextContext.class,i); 10033 } 10034 public List<JavadocInlineTagContext> javadocInlineTag() { 10035 return getRuleContexts(JavadocInlineTagContext.class); 10036 } 10037 public JavadocInlineTagContext javadocInlineTag(int i) { 10038 return getRuleContext(JavadocInlineTagContext.class,i); 10039 } 10040 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10041 public TerminalNode LEADING_ASTERISK(int i) { 10042 return getToken(JavadocParser.LEADING_ASTERISK, i); 10043 } 10044 public TbodyContext(ParserRuleContext parent, int invokingState) { 10045 super(parent, invokingState); 10046 } 10047 @Override public int getRuleIndex() { return RULE_tbody; } 10048 @Override 10049 public void enterRule(ParseTreeListener listener) { 10050 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbody(this); 10051 } 10052 @Override 10053 public void exitRule(ParseTreeListener listener) { 10054 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbody(this); 10055 } 10056 @Override 10057 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10058 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbody(this); 10059 else return visitor.visitChildren(this); 10060 } 10061 } 10062 10063 public final TbodyContext tbody() throws RecognitionException { 10064 TbodyContext _localctx = new TbodyContext(_ctx, getState()); 10065 enterRule(_localctx, 88, RULE_tbody); 10066 try { 10067 int _alt; 10068 enterOuterAlt(_localctx, 1); 10069 { 10070 setState(1158); 10071 tbodyTagOpen(); 10072 setState(1198); 10073 _errHandler.sync(this); 10074 _alt = getInterpreter().adaptivePredict(_input,81,_ctx); 10075 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10076 if ( _alt==1 ) { 10077 { 10078 setState(1196); 10079 switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) { 10080 case 1: 10081 { 10082 setState(1159); 10083 htmlTag(); 10084 } 10085 break; 10086 case 2: 10087 { 10088 setState(1160); 10089 singletonTag(); 10090 } 10091 break; 10092 case 3: 10093 { 10094 setState(1161); 10095 paragraph(); 10096 } 10097 break; 10098 case 4: 10099 { 10100 setState(1162); 10101 li(); 10102 } 10103 break; 10104 case 5: 10105 { 10106 setState(1163); 10107 tr(); 10108 } 10109 break; 10110 case 6: 10111 { 10112 setState(1164); 10113 td(); 10114 } 10115 break; 10116 case 7: 10117 { 10118 setState(1165); 10119 th(); 10120 } 10121 break; 10122 case 8: 10123 { 10124 setState(1166); 10125 body(); 10126 } 10127 break; 10128 case 9: 10129 { 10130 setState(1167); 10131 colgroup(); 10132 } 10133 break; 10134 case 10: 10135 { 10136 setState(1168); 10137 dd(); 10138 } 10139 break; 10140 case 11: 10141 { 10142 setState(1169); 10143 dt(); 10144 } 10145 break; 10146 case 12: 10147 { 10148 setState(1170); 10149 head(); 10150 } 10151 break; 10152 case 13: 10153 { 10154 setState(1171); 10155 html(); 10156 } 10157 break; 10158 case 14: 10159 { 10160 setState(1172); 10161 option(); 10162 } 10163 break; 10164 case 15: 10165 { 10166 setState(1173); 10167 thead(); 10168 } 10169 break; 10170 case 16: 10171 { 10172 setState(1174); 10173 tfoot(); 10174 } 10175 break; 10176 case 17: 10177 { 10178 setState(1175); 10179 pTagOpen(); 10180 } 10181 break; 10182 case 18: 10183 { 10184 setState(1176); 10185 liTagOpen(); 10186 } 10187 break; 10188 case 19: 10189 { 10190 setState(1177); 10191 trTagOpen(); 10192 } 10193 break; 10194 case 20: 10195 { 10196 setState(1178); 10197 tdTagOpen(); 10198 } 10199 break; 10200 case 21: 10201 { 10202 setState(1179); 10203 thTagOpen(); 10204 } 10205 break; 10206 case 22: 10207 { 10208 setState(1180); 10209 bodyTagOpen(); 10210 } 10211 break; 10212 case 23: 10213 { 10214 setState(1181); 10215 colgroupTagOpen(); 10216 } 10217 break; 10218 case 24: 10219 { 10220 setState(1182); 10221 ddTagOpen(); 10222 } 10223 break; 10224 case 25: 10225 { 10226 setState(1183); 10227 dtTagOpen(); 10228 } 10229 break; 10230 case 26: 10231 { 10232 setState(1184); 10233 headTagOpen(); 10234 } 10235 break; 10236 case 27: 10237 { 10238 setState(1185); 10239 htmlTagOpen(); 10240 } 10241 break; 10242 case 28: 10243 { 10244 setState(1186); 10245 optionTagOpen(); 10246 } 10247 break; 10248 case 29: 10249 { 10250 setState(1187); 10251 theadTagOpen(); 10252 } 10253 break; 10254 case 30: 10255 { 10256 setState(1188); 10257 tfootTagOpen(); 10258 } 10259 break; 10260 case 31: 10261 { 10262 { 10263 setState(1189); 10264 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10265 setState(1190); 10266 match(LEADING_ASTERISK); 10267 } 10268 } 10269 break; 10270 case 32: 10271 { 10272 setState(1191); 10273 htmlComment(); 10274 } 10275 break; 10276 case 33: 10277 { 10278 setState(1192); 10279 match(CDATA); 10280 } 10281 break; 10282 case 34: 10283 { 10284 setState(1193); 10285 match(NEWLINE); 10286 } 10287 break; 10288 case 35: 10289 { 10290 setState(1194); 10291 text(); 10292 } 10293 break; 10294 case 36: 10295 { 10296 setState(1195); 10297 javadocInlineTag(); 10298 } 10299 break; 10300 } 10301 } 10302 } 10303 setState(1200); 10304 _errHandler.sync(this); 10305 _alt = getInterpreter().adaptivePredict(_input,81,_ctx); 10306 } 10307 setState(1201); 10308 tbodyTagClose(); 10309 } 10310 } 10311 catch (RecognitionException re) { 10312 _localctx.exception = re; 10313 _errHandler.reportError(this, re); 10314 _errHandler.recover(this, re); 10315 } 10316 finally { 10317 exitRule(); 10318 } 10319 return _localctx; 10320 } 10321 10322 public static class TfootTagOpenContext extends ParserRuleContext { 10323 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10324 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 10325 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10326 public List<AttributeContext> attribute() { 10327 return getRuleContexts(AttributeContext.class); 10328 } 10329 public AttributeContext attribute(int i) { 10330 return getRuleContext(AttributeContext.class,i); 10331 } 10332 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10333 public TerminalNode NEWLINE(int i) { 10334 return getToken(JavadocParser.NEWLINE, i); 10335 } 10336 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10337 public TerminalNode LEADING_ASTERISK(int i) { 10338 return getToken(JavadocParser.LEADING_ASTERISK, i); 10339 } 10340 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10341 public TerminalNode WS(int i) { 10342 return getToken(JavadocParser.WS, i); 10343 } 10344 public TfootTagOpenContext(ParserRuleContext parent, int invokingState) { 10345 super(parent, invokingState); 10346 } 10347 @Override public int getRuleIndex() { return RULE_tfootTagOpen; } 10348 @Override 10349 public void enterRule(ParseTreeListener listener) { 10350 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagOpen(this); 10351 } 10352 @Override 10353 public void exitRule(ParseTreeListener listener) { 10354 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagOpen(this); 10355 } 10356 @Override 10357 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10358 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagOpen(this); 10359 else return visitor.visitChildren(this); 10360 } 10361 } 10362 10363 public final TfootTagOpenContext tfootTagOpen() throws RecognitionException { 10364 TfootTagOpenContext _localctx = new TfootTagOpenContext(_ctx, getState()); 10365 enterRule(_localctx, 90, RULE_tfootTagOpen); 10366 int _la; 10367 try { 10368 enterOuterAlt(_localctx, 1); 10369 { 10370 setState(1203); 10371 match(OPEN); 10372 setState(1204); 10373 match(TFOOT_HTML_TAG_NAME); 10374 setState(1211); 10375 _errHandler.sync(this); 10376 _la = _input.LA(1); 10377 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 10378 { 10379 setState(1209); 10380 switch (_input.LA(1)) { 10381 case HTML_TAG_NAME: 10382 { 10383 setState(1205); 10384 attribute(); 10385 } 10386 break; 10387 case NEWLINE: 10388 { 10389 setState(1206); 10390 match(NEWLINE); 10391 } 10392 break; 10393 case LEADING_ASTERISK: 10394 { 10395 setState(1207); 10396 match(LEADING_ASTERISK); 10397 } 10398 break; 10399 case WS: 10400 { 10401 setState(1208); 10402 match(WS); 10403 } 10404 break; 10405 default: 10406 throw new NoViableAltException(this); 10407 } 10408 } 10409 setState(1213); 10410 _errHandler.sync(this); 10411 _la = _input.LA(1); 10412 } 10413 setState(1214); 10414 match(CLOSE); 10415 } 10416 } 10417 catch (RecognitionException re) { 10418 _localctx.exception = re; 10419 _errHandler.reportError(this, re); 10420 _errHandler.recover(this, re); 10421 } 10422 finally { 10423 exitRule(); 10424 } 10425 return _localctx; 10426 } 10427 10428 public static class TfootTagCloseContext extends ParserRuleContext { 10429 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10430 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 10431 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 10432 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10433 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10434 public TerminalNode NEWLINE(int i) { 10435 return getToken(JavadocParser.NEWLINE, i); 10436 } 10437 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10438 public TerminalNode LEADING_ASTERISK(int i) { 10439 return getToken(JavadocParser.LEADING_ASTERISK, i); 10440 } 10441 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10442 public TerminalNode WS(int i) { 10443 return getToken(JavadocParser.WS, i); 10444 } 10445 public TfootTagCloseContext(ParserRuleContext parent, int invokingState) { 10446 super(parent, invokingState); 10447 } 10448 @Override public int getRuleIndex() { return RULE_tfootTagClose; } 10449 @Override 10450 public void enterRule(ParseTreeListener listener) { 10451 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagClose(this); 10452 } 10453 @Override 10454 public void exitRule(ParseTreeListener listener) { 10455 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagClose(this); 10456 } 10457 @Override 10458 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10459 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagClose(this); 10460 else return visitor.visitChildren(this); 10461 } 10462 } 10463 10464 public final TfootTagCloseContext tfootTagClose() throws RecognitionException { 10465 TfootTagCloseContext _localctx = new TfootTagCloseContext(_ctx, getState()); 10466 enterRule(_localctx, 92, RULE_tfootTagClose); 10467 int _la; 10468 try { 10469 enterOuterAlt(_localctx, 1); 10470 { 10471 setState(1216); 10472 match(OPEN); 10473 setState(1217); 10474 match(SLASH); 10475 setState(1218); 10476 match(TFOOT_HTML_TAG_NAME); 10477 setState(1222); 10478 _errHandler.sync(this); 10479 _la = _input.LA(1); 10480 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10481 { 10482 { 10483 setState(1219); 10484 _la = _input.LA(1); 10485 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10486 _errHandler.recoverInline(this); 10487 } else { 10488 consume(); 10489 } 10490 } 10491 } 10492 setState(1224); 10493 _errHandler.sync(this); 10494 _la = _input.LA(1); 10495 } 10496 setState(1225); 10497 match(CLOSE); 10498 } 10499 } 10500 catch (RecognitionException re) { 10501 _localctx.exception = re; 10502 _errHandler.reportError(this, re); 10503 _errHandler.recover(this, re); 10504 } 10505 finally { 10506 exitRule(); 10507 } 10508 return _localctx; 10509 } 10510 10511 public static class TfootContext extends ParserRuleContext { 10512 public TfootTagOpenContext tfootTagOpen() { 10513 return getRuleContext(TfootTagOpenContext.class,0); 10514 } 10515 public TfootTagCloseContext tfootTagClose() { 10516 return getRuleContext(TfootTagCloseContext.class,0); 10517 } 10518 public List<HtmlTagContext> htmlTag() { 10519 return getRuleContexts(HtmlTagContext.class); 10520 } 10521 public HtmlTagContext htmlTag(int i) { 10522 return getRuleContext(HtmlTagContext.class,i); 10523 } 10524 public List<SingletonTagContext> singletonTag() { 10525 return getRuleContexts(SingletonTagContext.class); 10526 } 10527 public SingletonTagContext singletonTag(int i) { 10528 return getRuleContext(SingletonTagContext.class,i); 10529 } 10530 public List<ParagraphContext> paragraph() { 10531 return getRuleContexts(ParagraphContext.class); 10532 } 10533 public ParagraphContext paragraph(int i) { 10534 return getRuleContext(ParagraphContext.class,i); 10535 } 10536 public List<LiContext> li() { 10537 return getRuleContexts(LiContext.class); 10538 } 10539 public LiContext li(int i) { 10540 return getRuleContext(LiContext.class,i); 10541 } 10542 public List<TrContext> tr() { 10543 return getRuleContexts(TrContext.class); 10544 } 10545 public TrContext tr(int i) { 10546 return getRuleContext(TrContext.class,i); 10547 } 10548 public List<TdContext> td() { 10549 return getRuleContexts(TdContext.class); 10550 } 10551 public TdContext td(int i) { 10552 return getRuleContext(TdContext.class,i); 10553 } 10554 public List<ThContext> th() { 10555 return getRuleContexts(ThContext.class); 10556 } 10557 public ThContext th(int i) { 10558 return getRuleContext(ThContext.class,i); 10559 } 10560 public List<BodyContext> body() { 10561 return getRuleContexts(BodyContext.class); 10562 } 10563 public BodyContext body(int i) { 10564 return getRuleContext(BodyContext.class,i); 10565 } 10566 public List<ColgroupContext> colgroup() { 10567 return getRuleContexts(ColgroupContext.class); 10568 } 10569 public ColgroupContext colgroup(int i) { 10570 return getRuleContext(ColgroupContext.class,i); 10571 } 10572 public List<DdContext> dd() { 10573 return getRuleContexts(DdContext.class); 10574 } 10575 public DdContext dd(int i) { 10576 return getRuleContext(DdContext.class,i); 10577 } 10578 public List<DtContext> dt() { 10579 return getRuleContexts(DtContext.class); 10580 } 10581 public DtContext dt(int i) { 10582 return getRuleContext(DtContext.class,i); 10583 } 10584 public List<HeadContext> head() { 10585 return getRuleContexts(HeadContext.class); 10586 } 10587 public HeadContext head(int i) { 10588 return getRuleContext(HeadContext.class,i); 10589 } 10590 public List<HtmlContext> html() { 10591 return getRuleContexts(HtmlContext.class); 10592 } 10593 public HtmlContext html(int i) { 10594 return getRuleContext(HtmlContext.class,i); 10595 } 10596 public List<OptionContext> option() { 10597 return getRuleContexts(OptionContext.class); 10598 } 10599 public OptionContext option(int i) { 10600 return getRuleContext(OptionContext.class,i); 10601 } 10602 public List<TbodyContext> tbody() { 10603 return getRuleContexts(TbodyContext.class); 10604 } 10605 public TbodyContext tbody(int i) { 10606 return getRuleContext(TbodyContext.class,i); 10607 } 10608 public List<TheadContext> thead() { 10609 return getRuleContexts(TheadContext.class); 10610 } 10611 public TheadContext thead(int i) { 10612 return getRuleContext(TheadContext.class,i); 10613 } 10614 public List<PTagOpenContext> pTagOpen() { 10615 return getRuleContexts(PTagOpenContext.class); 10616 } 10617 public PTagOpenContext pTagOpen(int i) { 10618 return getRuleContext(PTagOpenContext.class,i); 10619 } 10620 public List<LiTagOpenContext> liTagOpen() { 10621 return getRuleContexts(LiTagOpenContext.class); 10622 } 10623 public LiTagOpenContext liTagOpen(int i) { 10624 return getRuleContext(LiTagOpenContext.class,i); 10625 } 10626 public List<TrTagOpenContext> trTagOpen() { 10627 return getRuleContexts(TrTagOpenContext.class); 10628 } 10629 public TrTagOpenContext trTagOpen(int i) { 10630 return getRuleContext(TrTagOpenContext.class,i); 10631 } 10632 public List<TdTagOpenContext> tdTagOpen() { 10633 return getRuleContexts(TdTagOpenContext.class); 10634 } 10635 public TdTagOpenContext tdTagOpen(int i) { 10636 return getRuleContext(TdTagOpenContext.class,i); 10637 } 10638 public List<ThTagOpenContext> thTagOpen() { 10639 return getRuleContexts(ThTagOpenContext.class); 10640 } 10641 public ThTagOpenContext thTagOpen(int i) { 10642 return getRuleContext(ThTagOpenContext.class,i); 10643 } 10644 public List<BodyTagOpenContext> bodyTagOpen() { 10645 return getRuleContexts(BodyTagOpenContext.class); 10646 } 10647 public BodyTagOpenContext bodyTagOpen(int i) { 10648 return getRuleContext(BodyTagOpenContext.class,i); 10649 } 10650 public List<ColgroupTagOpenContext> colgroupTagOpen() { 10651 return getRuleContexts(ColgroupTagOpenContext.class); 10652 } 10653 public ColgroupTagOpenContext colgroupTagOpen(int i) { 10654 return getRuleContext(ColgroupTagOpenContext.class,i); 10655 } 10656 public List<DdTagOpenContext> ddTagOpen() { 10657 return getRuleContexts(DdTagOpenContext.class); 10658 } 10659 public DdTagOpenContext ddTagOpen(int i) { 10660 return getRuleContext(DdTagOpenContext.class,i); 10661 } 10662 public List<DtTagOpenContext> dtTagOpen() { 10663 return getRuleContexts(DtTagOpenContext.class); 10664 } 10665 public DtTagOpenContext dtTagOpen(int i) { 10666 return getRuleContext(DtTagOpenContext.class,i); 10667 } 10668 public List<HeadTagOpenContext> headTagOpen() { 10669 return getRuleContexts(HeadTagOpenContext.class); 10670 } 10671 public HeadTagOpenContext headTagOpen(int i) { 10672 return getRuleContext(HeadTagOpenContext.class,i); 10673 } 10674 public List<HtmlTagOpenContext> htmlTagOpen() { 10675 return getRuleContexts(HtmlTagOpenContext.class); 10676 } 10677 public HtmlTagOpenContext htmlTagOpen(int i) { 10678 return getRuleContext(HtmlTagOpenContext.class,i); 10679 } 10680 public List<OptionTagOpenContext> optionTagOpen() { 10681 return getRuleContexts(OptionTagOpenContext.class); 10682 } 10683 public OptionTagOpenContext optionTagOpen(int i) { 10684 return getRuleContext(OptionTagOpenContext.class,i); 10685 } 10686 public List<TbodyTagOpenContext> tbodyTagOpen() { 10687 return getRuleContexts(TbodyTagOpenContext.class); 10688 } 10689 public TbodyTagOpenContext tbodyTagOpen(int i) { 10690 return getRuleContext(TbodyTagOpenContext.class,i); 10691 } 10692 public List<TheadTagOpenContext> theadTagOpen() { 10693 return getRuleContexts(TheadTagOpenContext.class); 10694 } 10695 public TheadTagOpenContext theadTagOpen(int i) { 10696 return getRuleContext(TheadTagOpenContext.class,i); 10697 } 10698 public List<HtmlCommentContext> htmlComment() { 10699 return getRuleContexts(HtmlCommentContext.class); 10700 } 10701 public HtmlCommentContext htmlComment(int i) { 10702 return getRuleContext(HtmlCommentContext.class,i); 10703 } 10704 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10705 public TerminalNode CDATA(int i) { 10706 return getToken(JavadocParser.CDATA, i); 10707 } 10708 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10709 public TerminalNode NEWLINE(int i) { 10710 return getToken(JavadocParser.NEWLINE, i); 10711 } 10712 public List<TextContext> text() { 10713 return getRuleContexts(TextContext.class); 10714 } 10715 public TextContext text(int i) { 10716 return getRuleContext(TextContext.class,i); 10717 } 10718 public List<JavadocInlineTagContext> javadocInlineTag() { 10719 return getRuleContexts(JavadocInlineTagContext.class); 10720 } 10721 public JavadocInlineTagContext javadocInlineTag(int i) { 10722 return getRuleContext(JavadocInlineTagContext.class,i); 10723 } 10724 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10725 public TerminalNode LEADING_ASTERISK(int i) { 10726 return getToken(JavadocParser.LEADING_ASTERISK, i); 10727 } 10728 public TfootContext(ParserRuleContext parent, int invokingState) { 10729 super(parent, invokingState); 10730 } 10731 @Override public int getRuleIndex() { return RULE_tfoot; } 10732 @Override 10733 public void enterRule(ParseTreeListener listener) { 10734 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfoot(this); 10735 } 10736 @Override 10737 public void exitRule(ParseTreeListener listener) { 10738 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfoot(this); 10739 } 10740 @Override 10741 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10742 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfoot(this); 10743 else return visitor.visitChildren(this); 10744 } 10745 } 10746 10747 public final TfootContext tfoot() throws RecognitionException { 10748 TfootContext _localctx = new TfootContext(_ctx, getState()); 10749 enterRule(_localctx, 94, RULE_tfoot); 10750 try { 10751 int _alt; 10752 enterOuterAlt(_localctx, 1); 10753 { 10754 setState(1227); 10755 tfootTagOpen(); 10756 setState(1267); 10757 _errHandler.sync(this); 10758 _alt = getInterpreter().adaptivePredict(_input,86,_ctx); 10759 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10760 if ( _alt==1 ) { 10761 { 10762 setState(1265); 10763 switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) { 10764 case 1: 10765 { 10766 setState(1228); 10767 htmlTag(); 10768 } 10769 break; 10770 case 2: 10771 { 10772 setState(1229); 10773 singletonTag(); 10774 } 10775 break; 10776 case 3: 10777 { 10778 setState(1230); 10779 paragraph(); 10780 } 10781 break; 10782 case 4: 10783 { 10784 setState(1231); 10785 li(); 10786 } 10787 break; 10788 case 5: 10789 { 10790 setState(1232); 10791 tr(); 10792 } 10793 break; 10794 case 6: 10795 { 10796 setState(1233); 10797 td(); 10798 } 10799 break; 10800 case 7: 10801 { 10802 setState(1234); 10803 th(); 10804 } 10805 break; 10806 case 8: 10807 { 10808 setState(1235); 10809 body(); 10810 } 10811 break; 10812 case 9: 10813 { 10814 setState(1236); 10815 colgroup(); 10816 } 10817 break; 10818 case 10: 10819 { 10820 setState(1237); 10821 dd(); 10822 } 10823 break; 10824 case 11: 10825 { 10826 setState(1238); 10827 dt(); 10828 } 10829 break; 10830 case 12: 10831 { 10832 setState(1239); 10833 head(); 10834 } 10835 break; 10836 case 13: 10837 { 10838 setState(1240); 10839 html(); 10840 } 10841 break; 10842 case 14: 10843 { 10844 setState(1241); 10845 option(); 10846 } 10847 break; 10848 case 15: 10849 { 10850 setState(1242); 10851 tbody(); 10852 } 10853 break; 10854 case 16: 10855 { 10856 setState(1243); 10857 thead(); 10858 } 10859 break; 10860 case 17: 10861 { 10862 setState(1244); 10863 pTagOpen(); 10864 } 10865 break; 10866 case 18: 10867 { 10868 setState(1245); 10869 liTagOpen(); 10870 } 10871 break; 10872 case 19: 10873 { 10874 setState(1246); 10875 trTagOpen(); 10876 } 10877 break; 10878 case 20: 10879 { 10880 setState(1247); 10881 tdTagOpen(); 10882 } 10883 break; 10884 case 21: 10885 { 10886 setState(1248); 10887 thTagOpen(); 10888 } 10889 break; 10890 case 22: 10891 { 10892 setState(1249); 10893 bodyTagOpen(); 10894 } 10895 break; 10896 case 23: 10897 { 10898 setState(1250); 10899 colgroupTagOpen(); 10900 } 10901 break; 10902 case 24: 10903 { 10904 setState(1251); 10905 ddTagOpen(); 10906 } 10907 break; 10908 case 25: 10909 { 10910 setState(1252); 10911 dtTagOpen(); 10912 } 10913 break; 10914 case 26: 10915 { 10916 setState(1253); 10917 headTagOpen(); 10918 } 10919 break; 10920 case 27: 10921 { 10922 setState(1254); 10923 htmlTagOpen(); 10924 } 10925 break; 10926 case 28: 10927 { 10928 setState(1255); 10929 optionTagOpen(); 10930 } 10931 break; 10932 case 29: 10933 { 10934 setState(1256); 10935 tbodyTagOpen(); 10936 } 10937 break; 10938 case 30: 10939 { 10940 setState(1257); 10941 theadTagOpen(); 10942 } 10943 break; 10944 case 31: 10945 { 10946 { 10947 setState(1258); 10948 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10949 setState(1259); 10950 match(LEADING_ASTERISK); 10951 } 10952 } 10953 break; 10954 case 32: 10955 { 10956 setState(1260); 10957 htmlComment(); 10958 } 10959 break; 10960 case 33: 10961 { 10962 setState(1261); 10963 match(CDATA); 10964 } 10965 break; 10966 case 34: 10967 { 10968 setState(1262); 10969 match(NEWLINE); 10970 } 10971 break; 10972 case 35: 10973 { 10974 setState(1263); 10975 text(); 10976 } 10977 break; 10978 case 36: 10979 { 10980 setState(1264); 10981 javadocInlineTag(); 10982 } 10983 break; 10984 } 10985 } 10986 } 10987 setState(1269); 10988 _errHandler.sync(this); 10989 _alt = getInterpreter().adaptivePredict(_input,86,_ctx); 10990 } 10991 setState(1270); 10992 tfootTagClose(); 10993 } 10994 } 10995 catch (RecognitionException re) { 10996 _localctx.exception = re; 10997 _errHandler.reportError(this, re); 10998 _errHandler.recover(this, re); 10999 } 11000 finally { 11001 exitRule(); 11002 } 11003 return _localctx; 11004 } 11005 11006 public static class TheadTagOpenContext extends ParserRuleContext { 11007 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11008 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11009 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11010 public List<AttributeContext> attribute() { 11011 return getRuleContexts(AttributeContext.class); 11012 } 11013 public AttributeContext attribute(int i) { 11014 return getRuleContext(AttributeContext.class,i); 11015 } 11016 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11017 public TerminalNode NEWLINE(int i) { 11018 return getToken(JavadocParser.NEWLINE, i); 11019 } 11020 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11021 public TerminalNode LEADING_ASTERISK(int i) { 11022 return getToken(JavadocParser.LEADING_ASTERISK, i); 11023 } 11024 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11025 public TerminalNode WS(int i) { 11026 return getToken(JavadocParser.WS, i); 11027 } 11028 public TheadTagOpenContext(ParserRuleContext parent, int invokingState) { 11029 super(parent, invokingState); 11030 } 11031 @Override public int getRuleIndex() { return RULE_theadTagOpen; } 11032 @Override 11033 public void enterRule(ParseTreeListener listener) { 11034 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagOpen(this); 11035 } 11036 @Override 11037 public void exitRule(ParseTreeListener listener) { 11038 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagOpen(this); 11039 } 11040 @Override 11041 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11042 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagOpen(this); 11043 else return visitor.visitChildren(this); 11044 } 11045 } 11046 11047 public final TheadTagOpenContext theadTagOpen() throws RecognitionException { 11048 TheadTagOpenContext _localctx = new TheadTagOpenContext(_ctx, getState()); 11049 enterRule(_localctx, 96, RULE_theadTagOpen); 11050 int _la; 11051 try { 11052 enterOuterAlt(_localctx, 1); 11053 { 11054 setState(1272); 11055 match(OPEN); 11056 setState(1273); 11057 match(THEAD_HTML_TAG_NAME); 11058 setState(1280); 11059 _errHandler.sync(this); 11060 _la = _input.LA(1); 11061 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11062 { 11063 setState(1278); 11064 switch (_input.LA(1)) { 11065 case HTML_TAG_NAME: 11066 { 11067 setState(1274); 11068 attribute(); 11069 } 11070 break; 11071 case NEWLINE: 11072 { 11073 setState(1275); 11074 match(NEWLINE); 11075 } 11076 break; 11077 case LEADING_ASTERISK: 11078 { 11079 setState(1276); 11080 match(LEADING_ASTERISK); 11081 } 11082 break; 11083 case WS: 11084 { 11085 setState(1277); 11086 match(WS); 11087 } 11088 break; 11089 default: 11090 throw new NoViableAltException(this); 11091 } 11092 } 11093 setState(1282); 11094 _errHandler.sync(this); 11095 _la = _input.LA(1); 11096 } 11097 setState(1283); 11098 match(CLOSE); 11099 } 11100 } 11101 catch (RecognitionException re) { 11102 _localctx.exception = re; 11103 _errHandler.reportError(this, re); 11104 _errHandler.recover(this, re); 11105 } 11106 finally { 11107 exitRule(); 11108 } 11109 return _localctx; 11110 } 11111 11112 public static class TheadTagCloseContext extends ParserRuleContext { 11113 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11114 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 11115 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11116 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11117 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11118 public TerminalNode NEWLINE(int i) { 11119 return getToken(JavadocParser.NEWLINE, i); 11120 } 11121 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11122 public TerminalNode LEADING_ASTERISK(int i) { 11123 return getToken(JavadocParser.LEADING_ASTERISK, i); 11124 } 11125 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11126 public TerminalNode WS(int i) { 11127 return getToken(JavadocParser.WS, i); 11128 } 11129 public TheadTagCloseContext(ParserRuleContext parent, int invokingState) { 11130 super(parent, invokingState); 11131 } 11132 @Override public int getRuleIndex() { return RULE_theadTagClose; } 11133 @Override 11134 public void enterRule(ParseTreeListener listener) { 11135 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagClose(this); 11136 } 11137 @Override 11138 public void exitRule(ParseTreeListener listener) { 11139 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagClose(this); 11140 } 11141 @Override 11142 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11143 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagClose(this); 11144 else return visitor.visitChildren(this); 11145 } 11146 } 11147 11148 public final TheadTagCloseContext theadTagClose() throws RecognitionException { 11149 TheadTagCloseContext _localctx = new TheadTagCloseContext(_ctx, getState()); 11150 enterRule(_localctx, 98, RULE_theadTagClose); 11151 int _la; 11152 try { 11153 enterOuterAlt(_localctx, 1); 11154 { 11155 setState(1285); 11156 match(OPEN); 11157 setState(1286); 11158 match(SLASH); 11159 setState(1287); 11160 match(THEAD_HTML_TAG_NAME); 11161 setState(1291); 11162 _errHandler.sync(this); 11163 _la = _input.LA(1); 11164 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 11165 { 11166 { 11167 setState(1288); 11168 _la = _input.LA(1); 11169 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 11170 _errHandler.recoverInline(this); 11171 } else { 11172 consume(); 11173 } 11174 } 11175 } 11176 setState(1293); 11177 _errHandler.sync(this); 11178 _la = _input.LA(1); 11179 } 11180 setState(1294); 11181 match(CLOSE); 11182 } 11183 } 11184 catch (RecognitionException re) { 11185 _localctx.exception = re; 11186 _errHandler.reportError(this, re); 11187 _errHandler.recover(this, re); 11188 } 11189 finally { 11190 exitRule(); 11191 } 11192 return _localctx; 11193 } 11194 11195 public static class TheadContext extends ParserRuleContext { 11196 public TheadTagOpenContext theadTagOpen() { 11197 return getRuleContext(TheadTagOpenContext.class,0); 11198 } 11199 public TheadTagCloseContext theadTagClose() { 11200 return getRuleContext(TheadTagCloseContext.class,0); 11201 } 11202 public List<HtmlTagContext> htmlTag() { 11203 return getRuleContexts(HtmlTagContext.class); 11204 } 11205 public HtmlTagContext htmlTag(int i) { 11206 return getRuleContext(HtmlTagContext.class,i); 11207 } 11208 public List<SingletonTagContext> singletonTag() { 11209 return getRuleContexts(SingletonTagContext.class); 11210 } 11211 public SingletonTagContext singletonTag(int i) { 11212 return getRuleContext(SingletonTagContext.class,i); 11213 } 11214 public List<ParagraphContext> paragraph() { 11215 return getRuleContexts(ParagraphContext.class); 11216 } 11217 public ParagraphContext paragraph(int i) { 11218 return getRuleContext(ParagraphContext.class,i); 11219 } 11220 public List<LiContext> li() { 11221 return getRuleContexts(LiContext.class); 11222 } 11223 public LiContext li(int i) { 11224 return getRuleContext(LiContext.class,i); 11225 } 11226 public List<TrContext> tr() { 11227 return getRuleContexts(TrContext.class); 11228 } 11229 public TrContext tr(int i) { 11230 return getRuleContext(TrContext.class,i); 11231 } 11232 public List<TdContext> td() { 11233 return getRuleContexts(TdContext.class); 11234 } 11235 public TdContext td(int i) { 11236 return getRuleContext(TdContext.class,i); 11237 } 11238 public List<ThContext> th() { 11239 return getRuleContexts(ThContext.class); 11240 } 11241 public ThContext th(int i) { 11242 return getRuleContext(ThContext.class,i); 11243 } 11244 public List<BodyContext> body() { 11245 return getRuleContexts(BodyContext.class); 11246 } 11247 public BodyContext body(int i) { 11248 return getRuleContext(BodyContext.class,i); 11249 } 11250 public List<ColgroupContext> colgroup() { 11251 return getRuleContexts(ColgroupContext.class); 11252 } 11253 public ColgroupContext colgroup(int i) { 11254 return getRuleContext(ColgroupContext.class,i); 11255 } 11256 public List<DdContext> dd() { 11257 return getRuleContexts(DdContext.class); 11258 } 11259 public DdContext dd(int i) { 11260 return getRuleContext(DdContext.class,i); 11261 } 11262 public List<DtContext> dt() { 11263 return getRuleContexts(DtContext.class); 11264 } 11265 public DtContext dt(int i) { 11266 return getRuleContext(DtContext.class,i); 11267 } 11268 public List<HeadContext> head() { 11269 return getRuleContexts(HeadContext.class); 11270 } 11271 public HeadContext head(int i) { 11272 return getRuleContext(HeadContext.class,i); 11273 } 11274 public List<HtmlContext> html() { 11275 return getRuleContexts(HtmlContext.class); 11276 } 11277 public HtmlContext html(int i) { 11278 return getRuleContext(HtmlContext.class,i); 11279 } 11280 public List<OptionContext> option() { 11281 return getRuleContexts(OptionContext.class); 11282 } 11283 public OptionContext option(int i) { 11284 return getRuleContext(OptionContext.class,i); 11285 } 11286 public List<TbodyContext> tbody() { 11287 return getRuleContexts(TbodyContext.class); 11288 } 11289 public TbodyContext tbody(int i) { 11290 return getRuleContext(TbodyContext.class,i); 11291 } 11292 public List<TfootContext> tfoot() { 11293 return getRuleContexts(TfootContext.class); 11294 } 11295 public TfootContext tfoot(int i) { 11296 return getRuleContext(TfootContext.class,i); 11297 } 11298 public List<PTagOpenContext> pTagOpen() { 11299 return getRuleContexts(PTagOpenContext.class); 11300 } 11301 public PTagOpenContext pTagOpen(int i) { 11302 return getRuleContext(PTagOpenContext.class,i); 11303 } 11304 public List<LiTagOpenContext> liTagOpen() { 11305 return getRuleContexts(LiTagOpenContext.class); 11306 } 11307 public LiTagOpenContext liTagOpen(int i) { 11308 return getRuleContext(LiTagOpenContext.class,i); 11309 } 11310 public List<TrTagOpenContext> trTagOpen() { 11311 return getRuleContexts(TrTagOpenContext.class); 11312 } 11313 public TrTagOpenContext trTagOpen(int i) { 11314 return getRuleContext(TrTagOpenContext.class,i); 11315 } 11316 public List<TdTagOpenContext> tdTagOpen() { 11317 return getRuleContexts(TdTagOpenContext.class); 11318 } 11319 public TdTagOpenContext tdTagOpen(int i) { 11320 return getRuleContext(TdTagOpenContext.class,i); 11321 } 11322 public List<ThTagOpenContext> thTagOpen() { 11323 return getRuleContexts(ThTagOpenContext.class); 11324 } 11325 public ThTagOpenContext thTagOpen(int i) { 11326 return getRuleContext(ThTagOpenContext.class,i); 11327 } 11328 public List<BodyTagOpenContext> bodyTagOpen() { 11329 return getRuleContexts(BodyTagOpenContext.class); 11330 } 11331 public BodyTagOpenContext bodyTagOpen(int i) { 11332 return getRuleContext(BodyTagOpenContext.class,i); 11333 } 11334 public List<ColgroupTagOpenContext> colgroupTagOpen() { 11335 return getRuleContexts(ColgroupTagOpenContext.class); 11336 } 11337 public ColgroupTagOpenContext colgroupTagOpen(int i) { 11338 return getRuleContext(ColgroupTagOpenContext.class,i); 11339 } 11340 public List<DdTagOpenContext> ddTagOpen() { 11341 return getRuleContexts(DdTagOpenContext.class); 11342 } 11343 public DdTagOpenContext ddTagOpen(int i) { 11344 return getRuleContext(DdTagOpenContext.class,i); 11345 } 11346 public List<DtTagOpenContext> dtTagOpen() { 11347 return getRuleContexts(DtTagOpenContext.class); 11348 } 11349 public DtTagOpenContext dtTagOpen(int i) { 11350 return getRuleContext(DtTagOpenContext.class,i); 11351 } 11352 public List<HeadTagOpenContext> headTagOpen() { 11353 return getRuleContexts(HeadTagOpenContext.class); 11354 } 11355 public HeadTagOpenContext headTagOpen(int i) { 11356 return getRuleContext(HeadTagOpenContext.class,i); 11357 } 11358 public List<HtmlTagOpenContext> htmlTagOpen() { 11359 return getRuleContexts(HtmlTagOpenContext.class); 11360 } 11361 public HtmlTagOpenContext htmlTagOpen(int i) { 11362 return getRuleContext(HtmlTagOpenContext.class,i); 11363 } 11364 public List<OptionTagOpenContext> optionTagOpen() { 11365 return getRuleContexts(OptionTagOpenContext.class); 11366 } 11367 public OptionTagOpenContext optionTagOpen(int i) { 11368 return getRuleContext(OptionTagOpenContext.class,i); 11369 } 11370 public List<TbodyTagOpenContext> tbodyTagOpen() { 11371 return getRuleContexts(TbodyTagOpenContext.class); 11372 } 11373 public TbodyTagOpenContext tbodyTagOpen(int i) { 11374 return getRuleContext(TbodyTagOpenContext.class,i); 11375 } 11376 public List<TfootTagOpenContext> tfootTagOpen() { 11377 return getRuleContexts(TfootTagOpenContext.class); 11378 } 11379 public TfootTagOpenContext tfootTagOpen(int i) { 11380 return getRuleContext(TfootTagOpenContext.class,i); 11381 } 11382 public List<HtmlCommentContext> htmlComment() { 11383 return getRuleContexts(HtmlCommentContext.class); 11384 } 11385 public HtmlCommentContext htmlComment(int i) { 11386 return getRuleContext(HtmlCommentContext.class,i); 11387 } 11388 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 11389 public TerminalNode CDATA(int i) { 11390 return getToken(JavadocParser.CDATA, i); 11391 } 11392 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11393 public TerminalNode NEWLINE(int i) { 11394 return getToken(JavadocParser.NEWLINE, i); 11395 } 11396 public List<TextContext> text() { 11397 return getRuleContexts(TextContext.class); 11398 } 11399 public TextContext text(int i) { 11400 return getRuleContext(TextContext.class,i); 11401 } 11402 public List<JavadocInlineTagContext> javadocInlineTag() { 11403 return getRuleContexts(JavadocInlineTagContext.class); 11404 } 11405 public JavadocInlineTagContext javadocInlineTag(int i) { 11406 return getRuleContext(JavadocInlineTagContext.class,i); 11407 } 11408 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11409 public TerminalNode LEADING_ASTERISK(int i) { 11410 return getToken(JavadocParser.LEADING_ASTERISK, i); 11411 } 11412 public TheadContext(ParserRuleContext parent, int invokingState) { 11413 super(parent, invokingState); 11414 } 11415 @Override public int getRuleIndex() { return RULE_thead; } 11416 @Override 11417 public void enterRule(ParseTreeListener listener) { 11418 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThead(this); 11419 } 11420 @Override 11421 public void exitRule(ParseTreeListener listener) { 11422 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThead(this); 11423 } 11424 @Override 11425 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11426 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThead(this); 11427 else return visitor.visitChildren(this); 11428 } 11429 } 11430 11431 public final TheadContext thead() throws RecognitionException { 11432 TheadContext _localctx = new TheadContext(_ctx, getState()); 11433 enterRule(_localctx, 100, RULE_thead); 11434 try { 11435 int _alt; 11436 enterOuterAlt(_localctx, 1); 11437 { 11438 setState(1296); 11439 theadTagOpen(); 11440 setState(1336); 11441 _errHandler.sync(this); 11442 _alt = getInterpreter().adaptivePredict(_input,91,_ctx); 11443 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 11444 if ( _alt==1 ) { 11445 { 11446 setState(1334); 11447 switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) { 11448 case 1: 11449 { 11450 setState(1297); 11451 htmlTag(); 11452 } 11453 break; 11454 case 2: 11455 { 11456 setState(1298); 11457 singletonTag(); 11458 } 11459 break; 11460 case 3: 11461 { 11462 setState(1299); 11463 paragraph(); 11464 } 11465 break; 11466 case 4: 11467 { 11468 setState(1300); 11469 li(); 11470 } 11471 break; 11472 case 5: 11473 { 11474 setState(1301); 11475 tr(); 11476 } 11477 break; 11478 case 6: 11479 { 11480 setState(1302); 11481 td(); 11482 } 11483 break; 11484 case 7: 11485 { 11486 setState(1303); 11487 th(); 11488 } 11489 break; 11490 case 8: 11491 { 11492 setState(1304); 11493 body(); 11494 } 11495 break; 11496 case 9: 11497 { 11498 setState(1305); 11499 colgroup(); 11500 } 11501 break; 11502 case 10: 11503 { 11504 setState(1306); 11505 dd(); 11506 } 11507 break; 11508 case 11: 11509 { 11510 setState(1307); 11511 dt(); 11512 } 11513 break; 11514 case 12: 11515 { 11516 setState(1308); 11517 head(); 11518 } 11519 break; 11520 case 13: 11521 { 11522 setState(1309); 11523 html(); 11524 } 11525 break; 11526 case 14: 11527 { 11528 setState(1310); 11529 option(); 11530 } 11531 break; 11532 case 15: 11533 { 11534 setState(1311); 11535 tbody(); 11536 } 11537 break; 11538 case 16: 11539 { 11540 setState(1312); 11541 tfoot(); 11542 } 11543 break; 11544 case 17: 11545 { 11546 setState(1313); 11547 pTagOpen(); 11548 } 11549 break; 11550 case 18: 11551 { 11552 setState(1314); 11553 liTagOpen(); 11554 } 11555 break; 11556 case 19: 11557 { 11558 setState(1315); 11559 trTagOpen(); 11560 } 11561 break; 11562 case 20: 11563 { 11564 setState(1316); 11565 tdTagOpen(); 11566 } 11567 break; 11568 case 21: 11569 { 11570 setState(1317); 11571 thTagOpen(); 11572 } 11573 break; 11574 case 22: 11575 { 11576 setState(1318); 11577 bodyTagOpen(); 11578 } 11579 break; 11580 case 23: 11581 { 11582 setState(1319); 11583 colgroupTagOpen(); 11584 } 11585 break; 11586 case 24: 11587 { 11588 setState(1320); 11589 ddTagOpen(); 11590 } 11591 break; 11592 case 25: 11593 { 11594 setState(1321); 11595 dtTagOpen(); 11596 } 11597 break; 11598 case 26: 11599 { 11600 setState(1322); 11601 headTagOpen(); 11602 } 11603 break; 11604 case 27: 11605 { 11606 setState(1323); 11607 htmlTagOpen(); 11608 } 11609 break; 11610 case 28: 11611 { 11612 setState(1324); 11613 optionTagOpen(); 11614 } 11615 break; 11616 case 29: 11617 { 11618 setState(1325); 11619 tbodyTagOpen(); 11620 } 11621 break; 11622 case 30: 11623 { 11624 setState(1326); 11625 tfootTagOpen(); 11626 } 11627 break; 11628 case 31: 11629 { 11630 { 11631 setState(1327); 11632 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 11633 setState(1328); 11634 match(LEADING_ASTERISK); 11635 } 11636 } 11637 break; 11638 case 32: 11639 { 11640 setState(1329); 11641 htmlComment(); 11642 } 11643 break; 11644 case 33: 11645 { 11646 setState(1330); 11647 match(CDATA); 11648 } 11649 break; 11650 case 34: 11651 { 11652 setState(1331); 11653 match(NEWLINE); 11654 } 11655 break; 11656 case 35: 11657 { 11658 setState(1332); 11659 text(); 11660 } 11661 break; 11662 case 36: 11663 { 11664 setState(1333); 11665 javadocInlineTag(); 11666 } 11667 break; 11668 } 11669 } 11670 } 11671 setState(1338); 11672 _errHandler.sync(this); 11673 _alt = getInterpreter().adaptivePredict(_input,91,_ctx); 11674 } 11675 setState(1339); 11676 theadTagClose(); 11677 } 11678 } 11679 catch (RecognitionException re) { 11680 _localctx.exception = re; 11681 _errHandler.reportError(this, re); 11682 _errHandler.recover(this, re); 11683 } 11684 finally { 11685 exitRule(); 11686 } 11687 return _localctx; 11688 } 11689 11690 public static class SingletonElementContext extends ParserRuleContext { 11691 public SingletonTagContext singletonTag() { 11692 return getRuleContext(SingletonTagContext.class,0); 11693 } 11694 public AreaTagContext areaTag() { 11695 return getRuleContext(AreaTagContext.class,0); 11696 } 11697 public BaseTagContext baseTag() { 11698 return getRuleContext(BaseTagContext.class,0); 11699 } 11700 public BasefrontTagContext basefrontTag() { 11701 return getRuleContext(BasefrontTagContext.class,0); 11702 } 11703 public BrTagContext brTag() { 11704 return getRuleContext(BrTagContext.class,0); 11705 } 11706 public ColTagContext colTag() { 11707 return getRuleContext(ColTagContext.class,0); 11708 } 11709 public FrameTagContext frameTag() { 11710 return getRuleContext(FrameTagContext.class,0); 11711 } 11712 public HrTagContext hrTag() { 11713 return getRuleContext(HrTagContext.class,0); 11714 } 11715 public ImgTagContext imgTag() { 11716 return getRuleContext(ImgTagContext.class,0); 11717 } 11718 public InputTagContext inputTag() { 11719 return getRuleContext(InputTagContext.class,0); 11720 } 11721 public IsindexTagContext isindexTag() { 11722 return getRuleContext(IsindexTagContext.class,0); 11723 } 11724 public LinkTagContext linkTag() { 11725 return getRuleContext(LinkTagContext.class,0); 11726 } 11727 public MetaTagContext metaTag() { 11728 return getRuleContext(MetaTagContext.class,0); 11729 } 11730 public ParamTagContext paramTag() { 11731 return getRuleContext(ParamTagContext.class,0); 11732 } 11733 public WrongSinletonTagContext wrongSinletonTag() { 11734 return getRuleContext(WrongSinletonTagContext.class,0); 11735 } 11736 public SingletonElementContext(ParserRuleContext parent, int invokingState) { 11737 super(parent, invokingState); 11738 } 11739 @Override public int getRuleIndex() { return RULE_singletonElement; } 11740 @Override 11741 public void enterRule(ParseTreeListener listener) { 11742 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonElement(this); 11743 } 11744 @Override 11745 public void exitRule(ParseTreeListener listener) { 11746 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonElement(this); 11747 } 11748 @Override 11749 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11750 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonElement(this); 11751 else return visitor.visitChildren(this); 11752 } 11753 } 11754 11755 public final SingletonElementContext singletonElement() throws RecognitionException { 11756 SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState()); 11757 enterRule(_localctx, 102, RULE_singletonElement); 11758 try { 11759 setState(1356); 11760 switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) { 11761 case 1: 11762 enterOuterAlt(_localctx, 1); 11763 { 11764 setState(1341); 11765 singletonTag(); 11766 } 11767 break; 11768 case 2: 11769 enterOuterAlt(_localctx, 2); 11770 { 11771 setState(1342); 11772 areaTag(); 11773 } 11774 break; 11775 case 3: 11776 enterOuterAlt(_localctx, 3); 11777 { 11778 setState(1343); 11779 baseTag(); 11780 } 11781 break; 11782 case 4: 11783 enterOuterAlt(_localctx, 4); 11784 { 11785 setState(1344); 11786 basefrontTag(); 11787 } 11788 break; 11789 case 5: 11790 enterOuterAlt(_localctx, 5); 11791 { 11792 setState(1345); 11793 brTag(); 11794 } 11795 break; 11796 case 6: 11797 enterOuterAlt(_localctx, 6); 11798 { 11799 setState(1346); 11800 colTag(); 11801 } 11802 break; 11803 case 7: 11804 enterOuterAlt(_localctx, 7); 11805 { 11806 setState(1347); 11807 frameTag(); 11808 } 11809 break; 11810 case 8: 11811 enterOuterAlt(_localctx, 8); 11812 { 11813 setState(1348); 11814 hrTag(); 11815 } 11816 break; 11817 case 9: 11818 enterOuterAlt(_localctx, 9); 11819 { 11820 setState(1349); 11821 imgTag(); 11822 } 11823 break; 11824 case 10: 11825 enterOuterAlt(_localctx, 10); 11826 { 11827 setState(1350); 11828 inputTag(); 11829 } 11830 break; 11831 case 11: 11832 enterOuterAlt(_localctx, 11); 11833 { 11834 setState(1351); 11835 isindexTag(); 11836 } 11837 break; 11838 case 12: 11839 enterOuterAlt(_localctx, 12); 11840 { 11841 setState(1352); 11842 linkTag(); 11843 } 11844 break; 11845 case 13: 11846 enterOuterAlt(_localctx, 13); 11847 { 11848 setState(1353); 11849 metaTag(); 11850 } 11851 break; 11852 case 14: 11853 enterOuterAlt(_localctx, 14); 11854 { 11855 setState(1354); 11856 paramTag(); 11857 } 11858 break; 11859 case 15: 11860 enterOuterAlt(_localctx, 15); 11861 { 11862 setState(1355); 11863 wrongSinletonTag(); 11864 } 11865 break; 11866 } 11867 } 11868 catch (RecognitionException re) { 11869 _localctx.exception = re; 11870 _errHandler.reportError(this, re); 11871 _errHandler.recover(this, re); 11872 } 11873 finally { 11874 exitRule(); 11875 } 11876 return _localctx; 11877 } 11878 11879 public static class SingletonTagContext extends ParserRuleContext { 11880 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11881 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 11882 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 11883 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 11884 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 11885 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 11886 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 11887 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 11888 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 11889 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 11890 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 11891 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 11892 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 11893 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 11894 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 11895 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 11896 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 11897 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11898 public List<AttributeContext> attribute() { 11899 return getRuleContexts(AttributeContext.class); 11900 } 11901 public AttributeContext attribute(int i) { 11902 return getRuleContext(AttributeContext.class,i); 11903 } 11904 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11905 public TerminalNode NEWLINE(int i) { 11906 return getToken(JavadocParser.NEWLINE, i); 11907 } 11908 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11909 public TerminalNode LEADING_ASTERISK(int i) { 11910 return getToken(JavadocParser.LEADING_ASTERISK, i); 11911 } 11912 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11913 public TerminalNode WS(int i) { 11914 return getToken(JavadocParser.WS, i); 11915 } 11916 public SingletonTagContext(ParserRuleContext parent, int invokingState) { 11917 super(parent, invokingState); 11918 } 11919 @Override public int getRuleIndex() { return RULE_singletonTag; } 11920 @Override 11921 public void enterRule(ParseTreeListener listener) { 11922 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTag(this); 11923 } 11924 @Override 11925 public void exitRule(ParseTreeListener listener) { 11926 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTag(this); 11927 } 11928 @Override 11929 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11930 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTag(this); 11931 else return visitor.visitChildren(this); 11932 } 11933 } 11934 11935 public final SingletonTagContext singletonTag() throws RecognitionException { 11936 SingletonTagContext _localctx = new SingletonTagContext(_ctx, getState()); 11937 enterRule(_localctx, 104, RULE_singletonTag); 11938 int _la; 11939 try { 11940 enterOuterAlt(_localctx, 1); 11941 { 11942 setState(1358); 11943 match(OPEN); 11944 setState(1359); 11945 _la = _input.LA(1); 11946 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)) ) { 11947 _errHandler.recoverInline(this); 11948 } else { 11949 consume(); 11950 } 11951 setState(1366); 11952 _errHandler.sync(this); 11953 _la = _input.LA(1); 11954 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11955 { 11956 setState(1364); 11957 switch (_input.LA(1)) { 11958 case HTML_TAG_NAME: 11959 { 11960 setState(1360); 11961 attribute(); 11962 } 11963 break; 11964 case NEWLINE: 11965 { 11966 setState(1361); 11967 match(NEWLINE); 11968 } 11969 break; 11970 case LEADING_ASTERISK: 11971 { 11972 setState(1362); 11973 match(LEADING_ASTERISK); 11974 } 11975 break; 11976 case WS: 11977 { 11978 setState(1363); 11979 match(WS); 11980 } 11981 break; 11982 default: 11983 throw new NoViableAltException(this); 11984 } 11985 } 11986 setState(1368); 11987 _errHandler.sync(this); 11988 _la = _input.LA(1); 11989 } 11990 setState(1369); 11991 match(SLASH_CLOSE); 11992 } 11993 } 11994 catch (RecognitionException re) { 11995 _localctx.exception = re; 11996 _errHandler.reportError(this, re); 11997 _errHandler.recover(this, re); 11998 } 11999 finally { 12000 exitRule(); 12001 } 12002 return _localctx; 12003 } 12004 12005 public static class AreaTagContext extends ParserRuleContext { 12006 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12007 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 12008 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12009 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12010 public List<AttributeContext> attribute() { 12011 return getRuleContexts(AttributeContext.class); 12012 } 12013 public AttributeContext attribute(int i) { 12014 return getRuleContext(AttributeContext.class,i); 12015 } 12016 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12017 public TerminalNode NEWLINE(int i) { 12018 return getToken(JavadocParser.NEWLINE, i); 12019 } 12020 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12021 public TerminalNode LEADING_ASTERISK(int i) { 12022 return getToken(JavadocParser.LEADING_ASTERISK, i); 12023 } 12024 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12025 public TerminalNode WS(int i) { 12026 return getToken(JavadocParser.WS, i); 12027 } 12028 public AreaTagContext(ParserRuleContext parent, int invokingState) { 12029 super(parent, invokingState); 12030 } 12031 @Override public int getRuleIndex() { return RULE_areaTag; } 12032 @Override 12033 public void enterRule(ParseTreeListener listener) { 12034 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAreaTag(this); 12035 } 12036 @Override 12037 public void exitRule(ParseTreeListener listener) { 12038 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAreaTag(this); 12039 } 12040 @Override 12041 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12042 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAreaTag(this); 12043 else return visitor.visitChildren(this); 12044 } 12045 } 12046 12047 public final AreaTagContext areaTag() throws RecognitionException { 12048 AreaTagContext _localctx = new AreaTagContext(_ctx, getState()); 12049 enterRule(_localctx, 106, RULE_areaTag); 12050 int _la; 12051 try { 12052 enterOuterAlt(_localctx, 1); 12053 { 12054 setState(1371); 12055 match(OPEN); 12056 setState(1372); 12057 match(AREA_HTML_TAG_NAME); 12058 setState(1379); 12059 _errHandler.sync(this); 12060 _la = _input.LA(1); 12061 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12062 { 12063 setState(1377); 12064 switch (_input.LA(1)) { 12065 case HTML_TAG_NAME: 12066 { 12067 setState(1373); 12068 attribute(); 12069 } 12070 break; 12071 case NEWLINE: 12072 { 12073 setState(1374); 12074 match(NEWLINE); 12075 } 12076 break; 12077 case LEADING_ASTERISK: 12078 { 12079 setState(1375); 12080 match(LEADING_ASTERISK); 12081 } 12082 break; 12083 case WS: 12084 { 12085 setState(1376); 12086 match(WS); 12087 } 12088 break; 12089 default: 12090 throw new NoViableAltException(this); 12091 } 12092 } 12093 setState(1381); 12094 _errHandler.sync(this); 12095 _la = _input.LA(1); 12096 } 12097 setState(1382); 12098 _la = _input.LA(1); 12099 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12100 _errHandler.recoverInline(this); 12101 } else { 12102 consume(); 12103 } 12104 } 12105 } 12106 catch (RecognitionException re) { 12107 _localctx.exception = re; 12108 _errHandler.reportError(this, re); 12109 _errHandler.recover(this, re); 12110 } 12111 finally { 12112 exitRule(); 12113 } 12114 return _localctx; 12115 } 12116 12117 public static class BaseTagContext extends ParserRuleContext { 12118 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12119 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 12120 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12121 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12122 public List<AttributeContext> attribute() { 12123 return getRuleContexts(AttributeContext.class); 12124 } 12125 public AttributeContext attribute(int i) { 12126 return getRuleContext(AttributeContext.class,i); 12127 } 12128 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12129 public TerminalNode NEWLINE(int i) { 12130 return getToken(JavadocParser.NEWLINE, i); 12131 } 12132 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12133 public TerminalNode LEADING_ASTERISK(int i) { 12134 return getToken(JavadocParser.LEADING_ASTERISK, i); 12135 } 12136 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12137 public TerminalNode WS(int i) { 12138 return getToken(JavadocParser.WS, i); 12139 } 12140 public BaseTagContext(ParserRuleContext parent, int invokingState) { 12141 super(parent, invokingState); 12142 } 12143 @Override public int getRuleIndex() { return RULE_baseTag; } 12144 @Override 12145 public void enterRule(ParseTreeListener listener) { 12146 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBaseTag(this); 12147 } 12148 @Override 12149 public void exitRule(ParseTreeListener listener) { 12150 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBaseTag(this); 12151 } 12152 @Override 12153 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12154 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBaseTag(this); 12155 else return visitor.visitChildren(this); 12156 } 12157 } 12158 12159 public final BaseTagContext baseTag() throws RecognitionException { 12160 BaseTagContext _localctx = new BaseTagContext(_ctx, getState()); 12161 enterRule(_localctx, 108, RULE_baseTag); 12162 int _la; 12163 try { 12164 enterOuterAlt(_localctx, 1); 12165 { 12166 setState(1384); 12167 match(OPEN); 12168 setState(1385); 12169 match(BASE_HTML_TAG_NAME); 12170 setState(1392); 12171 _errHandler.sync(this); 12172 _la = _input.LA(1); 12173 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12174 { 12175 setState(1390); 12176 switch (_input.LA(1)) { 12177 case HTML_TAG_NAME: 12178 { 12179 setState(1386); 12180 attribute(); 12181 } 12182 break; 12183 case NEWLINE: 12184 { 12185 setState(1387); 12186 match(NEWLINE); 12187 } 12188 break; 12189 case LEADING_ASTERISK: 12190 { 12191 setState(1388); 12192 match(LEADING_ASTERISK); 12193 } 12194 break; 12195 case WS: 12196 { 12197 setState(1389); 12198 match(WS); 12199 } 12200 break; 12201 default: 12202 throw new NoViableAltException(this); 12203 } 12204 } 12205 setState(1394); 12206 _errHandler.sync(this); 12207 _la = _input.LA(1); 12208 } 12209 setState(1395); 12210 _la = _input.LA(1); 12211 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12212 _errHandler.recoverInline(this); 12213 } else { 12214 consume(); 12215 } 12216 } 12217 } 12218 catch (RecognitionException re) { 12219 _localctx.exception = re; 12220 _errHandler.reportError(this, re); 12221 _errHandler.recover(this, re); 12222 } 12223 finally { 12224 exitRule(); 12225 } 12226 return _localctx; 12227 } 12228 12229 public static class BasefrontTagContext extends ParserRuleContext { 12230 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12231 public TerminalNode BASEFRONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFRONT_HTML_TAG_NAME, 0); } 12232 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12233 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12234 public List<AttributeContext> attribute() { 12235 return getRuleContexts(AttributeContext.class); 12236 } 12237 public AttributeContext attribute(int i) { 12238 return getRuleContext(AttributeContext.class,i); 12239 } 12240 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12241 public TerminalNode NEWLINE(int i) { 12242 return getToken(JavadocParser.NEWLINE, i); 12243 } 12244 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12245 public TerminalNode LEADING_ASTERISK(int i) { 12246 return getToken(JavadocParser.LEADING_ASTERISK, i); 12247 } 12248 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12249 public TerminalNode WS(int i) { 12250 return getToken(JavadocParser.WS, i); 12251 } 12252 public BasefrontTagContext(ParserRuleContext parent, int invokingState) { 12253 super(parent, invokingState); 12254 } 12255 @Override public int getRuleIndex() { return RULE_basefrontTag; } 12256 @Override 12257 public void enterRule(ParseTreeListener listener) { 12258 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBasefrontTag(this); 12259 } 12260 @Override 12261 public void exitRule(ParseTreeListener listener) { 12262 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBasefrontTag(this); 12263 } 12264 @Override 12265 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12266 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBasefrontTag(this); 12267 else return visitor.visitChildren(this); 12268 } 12269 } 12270 12271 public final BasefrontTagContext basefrontTag() throws RecognitionException { 12272 BasefrontTagContext _localctx = new BasefrontTagContext(_ctx, getState()); 12273 enterRule(_localctx, 110, RULE_basefrontTag); 12274 int _la; 12275 try { 12276 enterOuterAlt(_localctx, 1); 12277 { 12278 setState(1397); 12279 match(OPEN); 12280 setState(1398); 12281 match(BASEFRONT_HTML_TAG_NAME); 12282 setState(1405); 12283 _errHandler.sync(this); 12284 _la = _input.LA(1); 12285 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12286 { 12287 setState(1403); 12288 switch (_input.LA(1)) { 12289 case HTML_TAG_NAME: 12290 { 12291 setState(1399); 12292 attribute(); 12293 } 12294 break; 12295 case NEWLINE: 12296 { 12297 setState(1400); 12298 match(NEWLINE); 12299 } 12300 break; 12301 case LEADING_ASTERISK: 12302 { 12303 setState(1401); 12304 match(LEADING_ASTERISK); 12305 } 12306 break; 12307 case WS: 12308 { 12309 setState(1402); 12310 match(WS); 12311 } 12312 break; 12313 default: 12314 throw new NoViableAltException(this); 12315 } 12316 } 12317 setState(1407); 12318 _errHandler.sync(this); 12319 _la = _input.LA(1); 12320 } 12321 setState(1408); 12322 _la = _input.LA(1); 12323 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12324 _errHandler.recoverInline(this); 12325 } else { 12326 consume(); 12327 } 12328 } 12329 } 12330 catch (RecognitionException re) { 12331 _localctx.exception = re; 12332 _errHandler.reportError(this, re); 12333 _errHandler.recover(this, re); 12334 } 12335 finally { 12336 exitRule(); 12337 } 12338 return _localctx; 12339 } 12340 12341 public static class BrTagContext extends ParserRuleContext { 12342 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12343 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 12344 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12345 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12346 public List<AttributeContext> attribute() { 12347 return getRuleContexts(AttributeContext.class); 12348 } 12349 public AttributeContext attribute(int i) { 12350 return getRuleContext(AttributeContext.class,i); 12351 } 12352 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12353 public TerminalNode NEWLINE(int i) { 12354 return getToken(JavadocParser.NEWLINE, i); 12355 } 12356 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12357 public TerminalNode LEADING_ASTERISK(int i) { 12358 return getToken(JavadocParser.LEADING_ASTERISK, i); 12359 } 12360 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12361 public TerminalNode WS(int i) { 12362 return getToken(JavadocParser.WS, i); 12363 } 12364 public BrTagContext(ParserRuleContext parent, int invokingState) { 12365 super(parent, invokingState); 12366 } 12367 @Override public int getRuleIndex() { return RULE_brTag; } 12368 @Override 12369 public void enterRule(ParseTreeListener listener) { 12370 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBrTag(this); 12371 } 12372 @Override 12373 public void exitRule(ParseTreeListener listener) { 12374 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBrTag(this); 12375 } 12376 @Override 12377 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12378 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBrTag(this); 12379 else return visitor.visitChildren(this); 12380 } 12381 } 12382 12383 public final BrTagContext brTag() throws RecognitionException { 12384 BrTagContext _localctx = new BrTagContext(_ctx, getState()); 12385 enterRule(_localctx, 112, RULE_brTag); 12386 int _la; 12387 try { 12388 enterOuterAlt(_localctx, 1); 12389 { 12390 setState(1410); 12391 match(OPEN); 12392 setState(1411); 12393 match(BR_HTML_TAG_NAME); 12394 setState(1418); 12395 _errHandler.sync(this); 12396 _la = _input.LA(1); 12397 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12398 { 12399 setState(1416); 12400 switch (_input.LA(1)) { 12401 case HTML_TAG_NAME: 12402 { 12403 setState(1412); 12404 attribute(); 12405 } 12406 break; 12407 case NEWLINE: 12408 { 12409 setState(1413); 12410 match(NEWLINE); 12411 } 12412 break; 12413 case LEADING_ASTERISK: 12414 { 12415 setState(1414); 12416 match(LEADING_ASTERISK); 12417 } 12418 break; 12419 case WS: 12420 { 12421 setState(1415); 12422 match(WS); 12423 } 12424 break; 12425 default: 12426 throw new NoViableAltException(this); 12427 } 12428 } 12429 setState(1420); 12430 _errHandler.sync(this); 12431 _la = _input.LA(1); 12432 } 12433 setState(1421); 12434 _la = _input.LA(1); 12435 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12436 _errHandler.recoverInline(this); 12437 } else { 12438 consume(); 12439 } 12440 } 12441 } 12442 catch (RecognitionException re) { 12443 _localctx.exception = re; 12444 _errHandler.reportError(this, re); 12445 _errHandler.recover(this, re); 12446 } 12447 finally { 12448 exitRule(); 12449 } 12450 return _localctx; 12451 } 12452 12453 public static class ColTagContext extends ParserRuleContext { 12454 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12455 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 12456 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12457 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12458 public List<AttributeContext> attribute() { 12459 return getRuleContexts(AttributeContext.class); 12460 } 12461 public AttributeContext attribute(int i) { 12462 return getRuleContext(AttributeContext.class,i); 12463 } 12464 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12465 public TerminalNode NEWLINE(int i) { 12466 return getToken(JavadocParser.NEWLINE, i); 12467 } 12468 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12469 public TerminalNode LEADING_ASTERISK(int i) { 12470 return getToken(JavadocParser.LEADING_ASTERISK, i); 12471 } 12472 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12473 public TerminalNode WS(int i) { 12474 return getToken(JavadocParser.WS, i); 12475 } 12476 public ColTagContext(ParserRuleContext parent, int invokingState) { 12477 super(parent, invokingState); 12478 } 12479 @Override public int getRuleIndex() { return RULE_colTag; } 12480 @Override 12481 public void enterRule(ParseTreeListener listener) { 12482 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColTag(this); 12483 } 12484 @Override 12485 public void exitRule(ParseTreeListener listener) { 12486 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColTag(this); 12487 } 12488 @Override 12489 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12490 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColTag(this); 12491 else return visitor.visitChildren(this); 12492 } 12493 } 12494 12495 public final ColTagContext colTag() throws RecognitionException { 12496 ColTagContext _localctx = new ColTagContext(_ctx, getState()); 12497 enterRule(_localctx, 114, RULE_colTag); 12498 int _la; 12499 try { 12500 enterOuterAlt(_localctx, 1); 12501 { 12502 setState(1423); 12503 match(OPEN); 12504 setState(1424); 12505 match(COL_HTML_TAG_NAME); 12506 setState(1431); 12507 _errHandler.sync(this); 12508 _la = _input.LA(1); 12509 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12510 { 12511 setState(1429); 12512 switch (_input.LA(1)) { 12513 case HTML_TAG_NAME: 12514 { 12515 setState(1425); 12516 attribute(); 12517 } 12518 break; 12519 case NEWLINE: 12520 { 12521 setState(1426); 12522 match(NEWLINE); 12523 } 12524 break; 12525 case LEADING_ASTERISK: 12526 { 12527 setState(1427); 12528 match(LEADING_ASTERISK); 12529 } 12530 break; 12531 case WS: 12532 { 12533 setState(1428); 12534 match(WS); 12535 } 12536 break; 12537 default: 12538 throw new NoViableAltException(this); 12539 } 12540 } 12541 setState(1433); 12542 _errHandler.sync(this); 12543 _la = _input.LA(1); 12544 } 12545 setState(1434); 12546 _la = _input.LA(1); 12547 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12548 _errHandler.recoverInline(this); 12549 } else { 12550 consume(); 12551 } 12552 } 12553 } 12554 catch (RecognitionException re) { 12555 _localctx.exception = re; 12556 _errHandler.reportError(this, re); 12557 _errHandler.recover(this, re); 12558 } 12559 finally { 12560 exitRule(); 12561 } 12562 return _localctx; 12563 } 12564 12565 public static class FrameTagContext extends ParserRuleContext { 12566 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12567 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 12568 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12569 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12570 public List<AttributeContext> attribute() { 12571 return getRuleContexts(AttributeContext.class); 12572 } 12573 public AttributeContext attribute(int i) { 12574 return getRuleContext(AttributeContext.class,i); 12575 } 12576 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12577 public TerminalNode NEWLINE(int i) { 12578 return getToken(JavadocParser.NEWLINE, i); 12579 } 12580 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12581 public TerminalNode LEADING_ASTERISK(int i) { 12582 return getToken(JavadocParser.LEADING_ASTERISK, i); 12583 } 12584 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12585 public TerminalNode WS(int i) { 12586 return getToken(JavadocParser.WS, i); 12587 } 12588 public FrameTagContext(ParserRuleContext parent, int invokingState) { 12589 super(parent, invokingState); 12590 } 12591 @Override public int getRuleIndex() { return RULE_frameTag; } 12592 @Override 12593 public void enterRule(ParseTreeListener listener) { 12594 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterFrameTag(this); 12595 } 12596 @Override 12597 public void exitRule(ParseTreeListener listener) { 12598 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitFrameTag(this); 12599 } 12600 @Override 12601 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12602 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitFrameTag(this); 12603 else return visitor.visitChildren(this); 12604 } 12605 } 12606 12607 public final FrameTagContext frameTag() throws RecognitionException { 12608 FrameTagContext _localctx = new FrameTagContext(_ctx, getState()); 12609 enterRule(_localctx, 116, RULE_frameTag); 12610 int _la; 12611 try { 12612 enterOuterAlt(_localctx, 1); 12613 { 12614 setState(1436); 12615 match(OPEN); 12616 setState(1437); 12617 match(FRAME_HTML_TAG_NAME); 12618 setState(1444); 12619 _errHandler.sync(this); 12620 _la = _input.LA(1); 12621 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12622 { 12623 setState(1442); 12624 switch (_input.LA(1)) { 12625 case HTML_TAG_NAME: 12626 { 12627 setState(1438); 12628 attribute(); 12629 } 12630 break; 12631 case NEWLINE: 12632 { 12633 setState(1439); 12634 match(NEWLINE); 12635 } 12636 break; 12637 case LEADING_ASTERISK: 12638 { 12639 setState(1440); 12640 match(LEADING_ASTERISK); 12641 } 12642 break; 12643 case WS: 12644 { 12645 setState(1441); 12646 match(WS); 12647 } 12648 break; 12649 default: 12650 throw new NoViableAltException(this); 12651 } 12652 } 12653 setState(1446); 12654 _errHandler.sync(this); 12655 _la = _input.LA(1); 12656 } 12657 setState(1447); 12658 _la = _input.LA(1); 12659 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12660 _errHandler.recoverInline(this); 12661 } else { 12662 consume(); 12663 } 12664 } 12665 } 12666 catch (RecognitionException re) { 12667 _localctx.exception = re; 12668 _errHandler.reportError(this, re); 12669 _errHandler.recover(this, re); 12670 } 12671 finally { 12672 exitRule(); 12673 } 12674 return _localctx; 12675 } 12676 12677 public static class HrTagContext extends ParserRuleContext { 12678 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12679 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 12680 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12681 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12682 public List<AttributeContext> attribute() { 12683 return getRuleContexts(AttributeContext.class); 12684 } 12685 public AttributeContext attribute(int i) { 12686 return getRuleContext(AttributeContext.class,i); 12687 } 12688 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12689 public TerminalNode NEWLINE(int i) { 12690 return getToken(JavadocParser.NEWLINE, i); 12691 } 12692 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12693 public TerminalNode LEADING_ASTERISK(int i) { 12694 return getToken(JavadocParser.LEADING_ASTERISK, i); 12695 } 12696 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12697 public TerminalNode WS(int i) { 12698 return getToken(JavadocParser.WS, i); 12699 } 12700 public HrTagContext(ParserRuleContext parent, int invokingState) { 12701 super(parent, invokingState); 12702 } 12703 @Override public int getRuleIndex() { return RULE_hrTag; } 12704 @Override 12705 public void enterRule(ParseTreeListener listener) { 12706 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHrTag(this); 12707 } 12708 @Override 12709 public void exitRule(ParseTreeListener listener) { 12710 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHrTag(this); 12711 } 12712 @Override 12713 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12714 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHrTag(this); 12715 else return visitor.visitChildren(this); 12716 } 12717 } 12718 12719 public final HrTagContext hrTag() throws RecognitionException { 12720 HrTagContext _localctx = new HrTagContext(_ctx, getState()); 12721 enterRule(_localctx, 118, RULE_hrTag); 12722 int _la; 12723 try { 12724 enterOuterAlt(_localctx, 1); 12725 { 12726 setState(1449); 12727 match(OPEN); 12728 setState(1450); 12729 match(HR_HTML_TAG_NAME); 12730 setState(1457); 12731 _errHandler.sync(this); 12732 _la = _input.LA(1); 12733 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12734 { 12735 setState(1455); 12736 switch (_input.LA(1)) { 12737 case HTML_TAG_NAME: 12738 { 12739 setState(1451); 12740 attribute(); 12741 } 12742 break; 12743 case NEWLINE: 12744 { 12745 setState(1452); 12746 match(NEWLINE); 12747 } 12748 break; 12749 case LEADING_ASTERISK: 12750 { 12751 setState(1453); 12752 match(LEADING_ASTERISK); 12753 } 12754 break; 12755 case WS: 12756 { 12757 setState(1454); 12758 match(WS); 12759 } 12760 break; 12761 default: 12762 throw new NoViableAltException(this); 12763 } 12764 } 12765 setState(1459); 12766 _errHandler.sync(this); 12767 _la = _input.LA(1); 12768 } 12769 setState(1460); 12770 _la = _input.LA(1); 12771 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12772 _errHandler.recoverInline(this); 12773 } else { 12774 consume(); 12775 } 12776 } 12777 } 12778 catch (RecognitionException re) { 12779 _localctx.exception = re; 12780 _errHandler.reportError(this, re); 12781 _errHandler.recover(this, re); 12782 } 12783 finally { 12784 exitRule(); 12785 } 12786 return _localctx; 12787 } 12788 12789 public static class ImgTagContext extends ParserRuleContext { 12790 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12791 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 12792 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12793 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12794 public List<AttributeContext> attribute() { 12795 return getRuleContexts(AttributeContext.class); 12796 } 12797 public AttributeContext attribute(int i) { 12798 return getRuleContext(AttributeContext.class,i); 12799 } 12800 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12801 public TerminalNode NEWLINE(int i) { 12802 return getToken(JavadocParser.NEWLINE, i); 12803 } 12804 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12805 public TerminalNode LEADING_ASTERISK(int i) { 12806 return getToken(JavadocParser.LEADING_ASTERISK, i); 12807 } 12808 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12809 public TerminalNode WS(int i) { 12810 return getToken(JavadocParser.WS, i); 12811 } 12812 public ImgTagContext(ParserRuleContext parent, int invokingState) { 12813 super(parent, invokingState); 12814 } 12815 @Override public int getRuleIndex() { return RULE_imgTag; } 12816 @Override 12817 public void enterRule(ParseTreeListener listener) { 12818 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterImgTag(this); 12819 } 12820 @Override 12821 public void exitRule(ParseTreeListener listener) { 12822 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitImgTag(this); 12823 } 12824 @Override 12825 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12826 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitImgTag(this); 12827 else return visitor.visitChildren(this); 12828 } 12829 } 12830 12831 public final ImgTagContext imgTag() throws RecognitionException { 12832 ImgTagContext _localctx = new ImgTagContext(_ctx, getState()); 12833 enterRule(_localctx, 120, RULE_imgTag); 12834 int _la; 12835 try { 12836 enterOuterAlt(_localctx, 1); 12837 { 12838 setState(1462); 12839 match(OPEN); 12840 setState(1463); 12841 match(IMG_HTML_TAG_NAME); 12842 setState(1470); 12843 _errHandler.sync(this); 12844 _la = _input.LA(1); 12845 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12846 { 12847 setState(1468); 12848 switch (_input.LA(1)) { 12849 case HTML_TAG_NAME: 12850 { 12851 setState(1464); 12852 attribute(); 12853 } 12854 break; 12855 case NEWLINE: 12856 { 12857 setState(1465); 12858 match(NEWLINE); 12859 } 12860 break; 12861 case LEADING_ASTERISK: 12862 { 12863 setState(1466); 12864 match(LEADING_ASTERISK); 12865 } 12866 break; 12867 case WS: 12868 { 12869 setState(1467); 12870 match(WS); 12871 } 12872 break; 12873 default: 12874 throw new NoViableAltException(this); 12875 } 12876 } 12877 setState(1472); 12878 _errHandler.sync(this); 12879 _la = _input.LA(1); 12880 } 12881 setState(1473); 12882 _la = _input.LA(1); 12883 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12884 _errHandler.recoverInline(this); 12885 } else { 12886 consume(); 12887 } 12888 } 12889 } 12890 catch (RecognitionException re) { 12891 _localctx.exception = re; 12892 _errHandler.reportError(this, re); 12893 _errHandler.recover(this, re); 12894 } 12895 finally { 12896 exitRule(); 12897 } 12898 return _localctx; 12899 } 12900 12901 public static class InputTagContext extends ParserRuleContext { 12902 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12903 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 12904 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12905 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12906 public List<AttributeContext> attribute() { 12907 return getRuleContexts(AttributeContext.class); 12908 } 12909 public AttributeContext attribute(int i) { 12910 return getRuleContext(AttributeContext.class,i); 12911 } 12912 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12913 public TerminalNode NEWLINE(int i) { 12914 return getToken(JavadocParser.NEWLINE, i); 12915 } 12916 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12917 public TerminalNode LEADING_ASTERISK(int i) { 12918 return getToken(JavadocParser.LEADING_ASTERISK, i); 12919 } 12920 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12921 public TerminalNode WS(int i) { 12922 return getToken(JavadocParser.WS, i); 12923 } 12924 public InputTagContext(ParserRuleContext parent, int invokingState) { 12925 super(parent, invokingState); 12926 } 12927 @Override public int getRuleIndex() { return RULE_inputTag; } 12928 @Override 12929 public void enterRule(ParseTreeListener listener) { 12930 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInputTag(this); 12931 } 12932 @Override 12933 public void exitRule(ParseTreeListener listener) { 12934 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInputTag(this); 12935 } 12936 @Override 12937 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12938 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInputTag(this); 12939 else return visitor.visitChildren(this); 12940 } 12941 } 12942 12943 public final InputTagContext inputTag() throws RecognitionException { 12944 InputTagContext _localctx = new InputTagContext(_ctx, getState()); 12945 enterRule(_localctx, 122, RULE_inputTag); 12946 int _la; 12947 try { 12948 enterOuterAlt(_localctx, 1); 12949 { 12950 setState(1475); 12951 match(OPEN); 12952 setState(1476); 12953 match(INPUT_HTML_TAG_NAME); 12954 setState(1483); 12955 _errHandler.sync(this); 12956 _la = _input.LA(1); 12957 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12958 { 12959 setState(1481); 12960 switch (_input.LA(1)) { 12961 case HTML_TAG_NAME: 12962 { 12963 setState(1477); 12964 attribute(); 12965 } 12966 break; 12967 case NEWLINE: 12968 { 12969 setState(1478); 12970 match(NEWLINE); 12971 } 12972 break; 12973 case LEADING_ASTERISK: 12974 { 12975 setState(1479); 12976 match(LEADING_ASTERISK); 12977 } 12978 break; 12979 case WS: 12980 { 12981 setState(1480); 12982 match(WS); 12983 } 12984 break; 12985 default: 12986 throw new NoViableAltException(this); 12987 } 12988 } 12989 setState(1485); 12990 _errHandler.sync(this); 12991 _la = _input.LA(1); 12992 } 12993 setState(1486); 12994 _la = _input.LA(1); 12995 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12996 _errHandler.recoverInline(this); 12997 } else { 12998 consume(); 12999 } 13000 } 13001 } 13002 catch (RecognitionException re) { 13003 _localctx.exception = re; 13004 _errHandler.reportError(this, re); 13005 _errHandler.recover(this, re); 13006 } 13007 finally { 13008 exitRule(); 13009 } 13010 return _localctx; 13011 } 13012 13013 public static class IsindexTagContext extends ParserRuleContext { 13014 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13015 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 13016 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13017 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13018 public List<AttributeContext> attribute() { 13019 return getRuleContexts(AttributeContext.class); 13020 } 13021 public AttributeContext attribute(int i) { 13022 return getRuleContext(AttributeContext.class,i); 13023 } 13024 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13025 public TerminalNode NEWLINE(int i) { 13026 return getToken(JavadocParser.NEWLINE, i); 13027 } 13028 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13029 public TerminalNode LEADING_ASTERISK(int i) { 13030 return getToken(JavadocParser.LEADING_ASTERISK, i); 13031 } 13032 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13033 public TerminalNode WS(int i) { 13034 return getToken(JavadocParser.WS, i); 13035 } 13036 public IsindexTagContext(ParserRuleContext parent, int invokingState) { 13037 super(parent, invokingState); 13038 } 13039 @Override public int getRuleIndex() { return RULE_isindexTag; } 13040 @Override 13041 public void enterRule(ParseTreeListener listener) { 13042 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterIsindexTag(this); 13043 } 13044 @Override 13045 public void exitRule(ParseTreeListener listener) { 13046 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitIsindexTag(this); 13047 } 13048 @Override 13049 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13050 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitIsindexTag(this); 13051 else return visitor.visitChildren(this); 13052 } 13053 } 13054 13055 public final IsindexTagContext isindexTag() throws RecognitionException { 13056 IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState()); 13057 enterRule(_localctx, 124, RULE_isindexTag); 13058 int _la; 13059 try { 13060 enterOuterAlt(_localctx, 1); 13061 { 13062 setState(1488); 13063 match(OPEN); 13064 setState(1489); 13065 match(ISINDEX_HTML_TAG_NAME); 13066 setState(1496); 13067 _errHandler.sync(this); 13068 _la = _input.LA(1); 13069 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13070 { 13071 setState(1494); 13072 switch (_input.LA(1)) { 13073 case HTML_TAG_NAME: 13074 { 13075 setState(1490); 13076 attribute(); 13077 } 13078 break; 13079 case NEWLINE: 13080 { 13081 setState(1491); 13082 match(NEWLINE); 13083 } 13084 break; 13085 case LEADING_ASTERISK: 13086 { 13087 setState(1492); 13088 match(LEADING_ASTERISK); 13089 } 13090 break; 13091 case WS: 13092 { 13093 setState(1493); 13094 match(WS); 13095 } 13096 break; 13097 default: 13098 throw new NoViableAltException(this); 13099 } 13100 } 13101 setState(1498); 13102 _errHandler.sync(this); 13103 _la = _input.LA(1); 13104 } 13105 setState(1499); 13106 _la = _input.LA(1); 13107 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13108 _errHandler.recoverInline(this); 13109 } else { 13110 consume(); 13111 } 13112 } 13113 } 13114 catch (RecognitionException re) { 13115 _localctx.exception = re; 13116 _errHandler.reportError(this, re); 13117 _errHandler.recover(this, re); 13118 } 13119 finally { 13120 exitRule(); 13121 } 13122 return _localctx; 13123 } 13124 13125 public static class LinkTagContext extends ParserRuleContext { 13126 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13127 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 13128 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13129 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13130 public List<AttributeContext> attribute() { 13131 return getRuleContexts(AttributeContext.class); 13132 } 13133 public AttributeContext attribute(int i) { 13134 return getRuleContext(AttributeContext.class,i); 13135 } 13136 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13137 public TerminalNode NEWLINE(int i) { 13138 return getToken(JavadocParser.NEWLINE, i); 13139 } 13140 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13141 public TerminalNode LEADING_ASTERISK(int i) { 13142 return getToken(JavadocParser.LEADING_ASTERISK, i); 13143 } 13144 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13145 public TerminalNode WS(int i) { 13146 return getToken(JavadocParser.WS, i); 13147 } 13148 public LinkTagContext(ParserRuleContext parent, int invokingState) { 13149 super(parent, invokingState); 13150 } 13151 @Override public int getRuleIndex() { return RULE_linkTag; } 13152 @Override 13153 public void enterRule(ParseTreeListener listener) { 13154 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLinkTag(this); 13155 } 13156 @Override 13157 public void exitRule(ParseTreeListener listener) { 13158 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLinkTag(this); 13159 } 13160 @Override 13161 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13162 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLinkTag(this); 13163 else return visitor.visitChildren(this); 13164 } 13165 } 13166 13167 public final LinkTagContext linkTag() throws RecognitionException { 13168 LinkTagContext _localctx = new LinkTagContext(_ctx, getState()); 13169 enterRule(_localctx, 126, RULE_linkTag); 13170 int _la; 13171 try { 13172 enterOuterAlt(_localctx, 1); 13173 { 13174 setState(1501); 13175 match(OPEN); 13176 setState(1502); 13177 match(LINK_HTML_TAG_NAME); 13178 setState(1509); 13179 _errHandler.sync(this); 13180 _la = _input.LA(1); 13181 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13182 { 13183 setState(1507); 13184 switch (_input.LA(1)) { 13185 case HTML_TAG_NAME: 13186 { 13187 setState(1503); 13188 attribute(); 13189 } 13190 break; 13191 case NEWLINE: 13192 { 13193 setState(1504); 13194 match(NEWLINE); 13195 } 13196 break; 13197 case LEADING_ASTERISK: 13198 { 13199 setState(1505); 13200 match(LEADING_ASTERISK); 13201 } 13202 break; 13203 case WS: 13204 { 13205 setState(1506); 13206 match(WS); 13207 } 13208 break; 13209 default: 13210 throw new NoViableAltException(this); 13211 } 13212 } 13213 setState(1511); 13214 _errHandler.sync(this); 13215 _la = _input.LA(1); 13216 } 13217 setState(1512); 13218 _la = _input.LA(1); 13219 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13220 _errHandler.recoverInline(this); 13221 } else { 13222 consume(); 13223 } 13224 } 13225 } 13226 catch (RecognitionException re) { 13227 _localctx.exception = re; 13228 _errHandler.reportError(this, re); 13229 _errHandler.recover(this, re); 13230 } 13231 finally { 13232 exitRule(); 13233 } 13234 return _localctx; 13235 } 13236 13237 public static class MetaTagContext extends ParserRuleContext { 13238 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13239 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 13240 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13241 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13242 public List<AttributeContext> attribute() { 13243 return getRuleContexts(AttributeContext.class); 13244 } 13245 public AttributeContext attribute(int i) { 13246 return getRuleContext(AttributeContext.class,i); 13247 } 13248 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13249 public TerminalNode NEWLINE(int i) { 13250 return getToken(JavadocParser.NEWLINE, i); 13251 } 13252 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13253 public TerminalNode LEADING_ASTERISK(int i) { 13254 return getToken(JavadocParser.LEADING_ASTERISK, i); 13255 } 13256 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13257 public TerminalNode WS(int i) { 13258 return getToken(JavadocParser.WS, i); 13259 } 13260 public MetaTagContext(ParserRuleContext parent, int invokingState) { 13261 super(parent, invokingState); 13262 } 13263 @Override public int getRuleIndex() { return RULE_metaTag; } 13264 @Override 13265 public void enterRule(ParseTreeListener listener) { 13266 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterMetaTag(this); 13267 } 13268 @Override 13269 public void exitRule(ParseTreeListener listener) { 13270 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitMetaTag(this); 13271 } 13272 @Override 13273 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13274 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitMetaTag(this); 13275 else return visitor.visitChildren(this); 13276 } 13277 } 13278 13279 public final MetaTagContext metaTag() throws RecognitionException { 13280 MetaTagContext _localctx = new MetaTagContext(_ctx, getState()); 13281 enterRule(_localctx, 128, RULE_metaTag); 13282 int _la; 13283 try { 13284 enterOuterAlt(_localctx, 1); 13285 { 13286 setState(1514); 13287 match(OPEN); 13288 setState(1515); 13289 match(META_HTML_TAG_NAME); 13290 setState(1522); 13291 _errHandler.sync(this); 13292 _la = _input.LA(1); 13293 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13294 { 13295 setState(1520); 13296 switch (_input.LA(1)) { 13297 case HTML_TAG_NAME: 13298 { 13299 setState(1516); 13300 attribute(); 13301 } 13302 break; 13303 case NEWLINE: 13304 { 13305 setState(1517); 13306 match(NEWLINE); 13307 } 13308 break; 13309 case LEADING_ASTERISK: 13310 { 13311 setState(1518); 13312 match(LEADING_ASTERISK); 13313 } 13314 break; 13315 case WS: 13316 { 13317 setState(1519); 13318 match(WS); 13319 } 13320 break; 13321 default: 13322 throw new NoViableAltException(this); 13323 } 13324 } 13325 setState(1524); 13326 _errHandler.sync(this); 13327 _la = _input.LA(1); 13328 } 13329 setState(1525); 13330 _la = _input.LA(1); 13331 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13332 _errHandler.recoverInline(this); 13333 } else { 13334 consume(); 13335 } 13336 } 13337 } 13338 catch (RecognitionException re) { 13339 _localctx.exception = re; 13340 _errHandler.reportError(this, re); 13341 _errHandler.recover(this, re); 13342 } 13343 finally { 13344 exitRule(); 13345 } 13346 return _localctx; 13347 } 13348 13349 public static class ParamTagContext extends ParserRuleContext { 13350 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13351 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 13352 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13353 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13354 public List<AttributeContext> attribute() { 13355 return getRuleContexts(AttributeContext.class); 13356 } 13357 public AttributeContext attribute(int i) { 13358 return getRuleContext(AttributeContext.class,i); 13359 } 13360 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13361 public TerminalNode NEWLINE(int i) { 13362 return getToken(JavadocParser.NEWLINE, i); 13363 } 13364 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13365 public TerminalNode LEADING_ASTERISK(int i) { 13366 return getToken(JavadocParser.LEADING_ASTERISK, i); 13367 } 13368 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13369 public TerminalNode WS(int i) { 13370 return getToken(JavadocParser.WS, i); 13371 } 13372 public ParamTagContext(ParserRuleContext parent, int invokingState) { 13373 super(parent, invokingState); 13374 } 13375 @Override public int getRuleIndex() { return RULE_paramTag; } 13376 @Override 13377 public void enterRule(ParseTreeListener listener) { 13378 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParamTag(this); 13379 } 13380 @Override 13381 public void exitRule(ParseTreeListener listener) { 13382 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParamTag(this); 13383 } 13384 @Override 13385 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13386 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParamTag(this); 13387 else return visitor.visitChildren(this); 13388 } 13389 } 13390 13391 public final ParamTagContext paramTag() throws RecognitionException { 13392 ParamTagContext _localctx = new ParamTagContext(_ctx, getState()); 13393 enterRule(_localctx, 130, RULE_paramTag); 13394 int _la; 13395 try { 13396 enterOuterAlt(_localctx, 1); 13397 { 13398 setState(1527); 13399 match(OPEN); 13400 setState(1528); 13401 match(PARAM_HTML_TAG_NAME); 13402 setState(1535); 13403 _errHandler.sync(this); 13404 _la = _input.LA(1); 13405 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13406 { 13407 setState(1533); 13408 switch (_input.LA(1)) { 13409 case HTML_TAG_NAME: 13410 { 13411 setState(1529); 13412 attribute(); 13413 } 13414 break; 13415 case NEWLINE: 13416 { 13417 setState(1530); 13418 match(NEWLINE); 13419 } 13420 break; 13421 case LEADING_ASTERISK: 13422 { 13423 setState(1531); 13424 match(LEADING_ASTERISK); 13425 } 13426 break; 13427 case WS: 13428 { 13429 setState(1532); 13430 match(WS); 13431 } 13432 break; 13433 default: 13434 throw new NoViableAltException(this); 13435 } 13436 } 13437 setState(1537); 13438 _errHandler.sync(this); 13439 _la = _input.LA(1); 13440 } 13441 setState(1538); 13442 _la = _input.LA(1); 13443 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13444 _errHandler.recoverInline(this); 13445 } else { 13446 consume(); 13447 } 13448 } 13449 } 13450 catch (RecognitionException re) { 13451 _localctx.exception = re; 13452 _errHandler.reportError(this, re); 13453 _errHandler.recover(this, re); 13454 } 13455 finally { 13456 exitRule(); 13457 } 13458 return _localctx; 13459 } 13460 13461 public static class WrongSinletonTagContext extends ParserRuleContext { 13462 public SingletonTagNameContext singletonTagName; 13463 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13464 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 13465 public SingletonTagNameContext singletonTagName() { 13466 return getRuleContext(SingletonTagNameContext.class,0); 13467 } 13468 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13469 public WrongSinletonTagContext(ParserRuleContext parent, int invokingState) { 13470 super(parent, invokingState); 13471 } 13472 @Override public int getRuleIndex() { return RULE_wrongSinletonTag; } 13473 @Override 13474 public void enterRule(ParseTreeListener listener) { 13475 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterWrongSinletonTag(this); 13476 } 13477 @Override 13478 public void exitRule(ParseTreeListener listener) { 13479 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitWrongSinletonTag(this); 13480 } 13481 @Override 13482 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13483 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWrongSinletonTag(this); 13484 else return visitor.visitChildren(this); 13485 } 13486 } 13487 13488 public final WrongSinletonTagContext wrongSinletonTag() throws RecognitionException { 13489 WrongSinletonTagContext _localctx = new WrongSinletonTagContext(_ctx, getState()); 13490 enterRule(_localctx, 132, RULE_wrongSinletonTag); 13491 try { 13492 enterOuterAlt(_localctx, 1); 13493 { 13494 setState(1540); 13495 match(OPEN); 13496 setState(1541); 13497 match(SLASH); 13498 setState(1542); 13499 ((WrongSinletonTagContext)_localctx).singletonTagName = singletonTagName(); 13500 setState(1543); 13501 match(CLOSE); 13502 notifyErrorListeners((((WrongSinletonTagContext)_localctx).singletonTagName!=null?(((WrongSinletonTagContext)_localctx).singletonTagName.start):null), "javadoc.wrong.singleton.html.tag", null); 13503 } 13504 } 13505 catch (RecognitionException re) { 13506 _localctx.exception = re; 13507 _errHandler.reportError(this, re); 13508 _errHandler.recover(this, re); 13509 } 13510 finally { 13511 exitRule(); 13512 } 13513 return _localctx; 13514 } 13515 13516 public static class SingletonTagNameContext extends ParserRuleContext { 13517 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 13518 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 13519 public TerminalNode BASEFRONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFRONT_HTML_TAG_NAME, 0); } 13520 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 13521 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 13522 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 13523 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 13524 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 13525 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 13526 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 13527 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 13528 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 13529 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 13530 public SingletonTagNameContext(ParserRuleContext parent, int invokingState) { 13531 super(parent, invokingState); 13532 } 13533 @Override public int getRuleIndex() { return RULE_singletonTagName; } 13534 @Override 13535 public void enterRule(ParseTreeListener listener) { 13536 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTagName(this); 13537 } 13538 @Override 13539 public void exitRule(ParseTreeListener listener) { 13540 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTagName(this); 13541 } 13542 @Override 13543 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13544 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTagName(this); 13545 else return visitor.visitChildren(this); 13546 } 13547 } 13548 13549 public final SingletonTagNameContext singletonTagName() throws RecognitionException { 13550 SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState()); 13551 enterRule(_localctx, 134, RULE_singletonTagName); 13552 int _la; 13553 try { 13554 enterOuterAlt(_localctx, 1); 13555 { 13556 setState(1546); 13557 _la = _input.LA(1); 13558 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)) ) { 13559 _errHandler.recoverInline(this); 13560 } else { 13561 consume(); 13562 } 13563 } 13564 } 13565 catch (RecognitionException re) { 13566 _localctx.exception = re; 13567 _errHandler.reportError(this, re); 13568 _errHandler.recover(this, re); 13569 } 13570 finally { 13571 exitRule(); 13572 } 13573 return _localctx; 13574 } 13575 13576 public static class DescriptionContext extends ParserRuleContext { 13577 public List<HtmlCommentContext> htmlComment() { 13578 return getRuleContexts(HtmlCommentContext.class); 13579 } 13580 public HtmlCommentContext htmlComment(int i) { 13581 return getRuleContext(HtmlCommentContext.class,i); 13582 } 13583 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 13584 public TerminalNode CDATA(int i) { 13585 return getToken(JavadocParser.CDATA, i); 13586 } 13587 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13588 public TerminalNode NEWLINE(int i) { 13589 return getToken(JavadocParser.NEWLINE, i); 13590 } 13591 public List<TextContext> text() { 13592 return getRuleContexts(TextContext.class); 13593 } 13594 public TextContext text(int i) { 13595 return getRuleContext(TextContext.class,i); 13596 } 13597 public List<JavadocInlineTagContext> javadocInlineTag() { 13598 return getRuleContexts(JavadocInlineTagContext.class); 13599 } 13600 public JavadocInlineTagContext javadocInlineTag(int i) { 13601 return getRuleContext(JavadocInlineTagContext.class,i); 13602 } 13603 public List<HtmlElementContext> htmlElement() { 13604 return getRuleContexts(HtmlElementContext.class); 13605 } 13606 public HtmlElementContext htmlElement(int i) { 13607 return getRuleContext(HtmlElementContext.class,i); 13608 } 13609 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13610 public TerminalNode LEADING_ASTERISK(int i) { 13611 return getToken(JavadocParser.LEADING_ASTERISK, i); 13612 } 13613 public DescriptionContext(ParserRuleContext parent, int invokingState) { 13614 super(parent, invokingState); 13615 } 13616 @Override public int getRuleIndex() { return RULE_description; } 13617 @Override 13618 public void enterRule(ParseTreeListener listener) { 13619 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescription(this); 13620 } 13621 @Override 13622 public void exitRule(ParseTreeListener listener) { 13623 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescription(this); 13624 } 13625 @Override 13626 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13627 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this); 13628 else return visitor.visitChildren(this); 13629 } 13630 } 13631 13632 public final DescriptionContext description() throws RecognitionException { 13633 DescriptionContext _localctx = new DescriptionContext(_ctx, getState()); 13634 enterRule(_localctx, 136, RULE_description); 13635 try { 13636 int _alt; 13637 enterOuterAlt(_localctx, 1); 13638 { 13639 setState(1556); 13640 _errHandler.sync(this); 13641 _alt = 1; 13642 do { 13643 switch (_alt) { 13644 case 1: 13645 { 13646 setState(1556); 13647 switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) { 13648 case 1: 13649 { 13650 { 13651 setState(1548); 13652 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 13653 setState(1549); 13654 match(LEADING_ASTERISK); 13655 } 13656 } 13657 break; 13658 case 2: 13659 { 13660 setState(1550); 13661 htmlComment(); 13662 } 13663 break; 13664 case 3: 13665 { 13666 setState(1551); 13667 match(CDATA); 13668 } 13669 break; 13670 case 4: 13671 { 13672 setState(1552); 13673 match(NEWLINE); 13674 } 13675 break; 13676 case 5: 13677 { 13678 setState(1553); 13679 text(); 13680 } 13681 break; 13682 case 6: 13683 { 13684 setState(1554); 13685 javadocInlineTag(); 13686 } 13687 break; 13688 case 7: 13689 { 13690 setState(1555); 13691 htmlElement(); 13692 } 13693 break; 13694 } 13695 } 13696 break; 13697 default: 13698 throw new NoViableAltException(this); 13699 } 13700 setState(1558); 13701 _errHandler.sync(this); 13702 _alt = getInterpreter().adaptivePredict(_input,122,_ctx); 13703 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13704 } 13705 } 13706 catch (RecognitionException re) { 13707 _localctx.exception = re; 13708 _errHandler.reportError(this, re); 13709 _errHandler.recover(this, re); 13710 } 13711 finally { 13712 exitRule(); 13713 } 13714 return _localctx; 13715 } 13716 13717 public static class ReferenceContext extends ParserRuleContext { 13718 public TerminalNode PACKAGE() { return getToken(JavadocParser.PACKAGE, 0); } 13719 public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); } 13720 public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); } 13721 public ParametersContext parameters() { 13722 return getRuleContext(ParametersContext.class,0); 13723 } 13724 public List<TerminalNode> DOT() { return getTokens(JavadocParser.DOT); } 13725 public TerminalNode DOT(int i) { 13726 return getToken(JavadocParser.DOT, i); 13727 } 13728 public List<TerminalNode> CLASS() { return getTokens(JavadocParser.CLASS); } 13729 public TerminalNode CLASS(int i) { 13730 return getToken(JavadocParser.CLASS, i); 13731 } 13732 public ReferenceContext(ParserRuleContext parent, int invokingState) { 13733 super(parent, invokingState); 13734 } 13735 @Override public int getRuleIndex() { return RULE_reference; } 13736 @Override 13737 public void enterRule(ParseTreeListener listener) { 13738 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterReference(this); 13739 } 13740 @Override 13741 public void exitRule(ParseTreeListener listener) { 13742 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitReference(this); 13743 } 13744 @Override 13745 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13746 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitReference(this); 13747 else return visitor.visitChildren(this); 13748 } 13749 } 13750 13751 public final ReferenceContext reference() throws RecognitionException { 13752 ReferenceContext _localctx = new ReferenceContext(_ctx, getState()); 13753 enterRule(_localctx, 138, RULE_reference); 13754 int _la; 13755 try { 13756 int _alt; 13757 enterOuterAlt(_localctx, 1); 13758 { 13759 setState(1597); 13760 switch (_input.LA(1)) { 13761 case PACKAGE: 13762 { 13763 setState(1560); 13764 match(PACKAGE); 13765 setState(1564); 13766 _errHandler.sync(this); 13767 _alt = getInterpreter().adaptivePredict(_input,123,_ctx); 13768 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13769 if ( _alt==1 ) { 13770 { 13771 { 13772 setState(1561); 13773 _la = _input.LA(1); 13774 if ( !(_la==DOT || _la==CLASS) ) { 13775 _errHandler.recoverInline(this); 13776 } else { 13777 consume(); 13778 } 13779 } 13780 } 13781 } 13782 setState(1566); 13783 _errHandler.sync(this); 13784 _alt = getInterpreter().adaptivePredict(_input,123,_ctx); 13785 } 13786 setState(1568); 13787 switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) { 13788 case 1: 13789 { 13790 setState(1567); 13791 match(HASH); 13792 } 13793 break; 13794 } 13795 setState(1571); 13796 switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) { 13797 case 1: 13798 { 13799 setState(1570); 13800 match(MEMBER); 13801 } 13802 break; 13803 } 13804 setState(1574); 13805 switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) { 13806 case 1: 13807 { 13808 setState(1573); 13809 parameters(); 13810 } 13811 break; 13812 } 13813 } 13814 break; 13815 case DOT: 13816 case CLASS: 13817 { 13818 setState(1577); 13819 _errHandler.sync(this); 13820 _alt = 1; 13821 do { 13822 switch (_alt) { 13823 case 1: 13824 { 13825 { 13826 setState(1576); 13827 _la = _input.LA(1); 13828 if ( !(_la==DOT || _la==CLASS) ) { 13829 _errHandler.recoverInline(this); 13830 } else { 13831 consume(); 13832 } 13833 } 13834 } 13835 break; 13836 default: 13837 throw new NoViableAltException(this); 13838 } 13839 setState(1579); 13840 _errHandler.sync(this); 13841 _alt = getInterpreter().adaptivePredict(_input,127,_ctx); 13842 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13843 setState(1582); 13844 switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { 13845 case 1: 13846 { 13847 setState(1581); 13848 match(HASH); 13849 } 13850 break; 13851 } 13852 setState(1585); 13853 switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) { 13854 case 1: 13855 { 13856 setState(1584); 13857 match(MEMBER); 13858 } 13859 break; 13860 } 13861 setState(1588); 13862 switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) { 13863 case 1: 13864 { 13865 setState(1587); 13866 parameters(); 13867 } 13868 break; 13869 } 13870 } 13871 break; 13872 case HASH: 13873 case MEMBER: 13874 { 13875 setState(1591); 13876 _la = _input.LA(1); 13877 if (_la==HASH) { 13878 { 13879 setState(1590); 13880 match(HASH); 13881 } 13882 } 13883 13884 setState(1593); 13885 match(MEMBER); 13886 setState(1595); 13887 switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { 13888 case 1: 13889 { 13890 setState(1594); 13891 parameters(); 13892 } 13893 break; 13894 } 13895 } 13896 break; 13897 default: 13898 throw new NoViableAltException(this); 13899 } 13900 } 13901 } 13902 catch (RecognitionException re) { 13903 _localctx.exception = re; 13904 _errHandler.reportError(this, re); 13905 _errHandler.recover(this, re); 13906 } 13907 finally { 13908 exitRule(); 13909 } 13910 return _localctx; 13911 } 13912 13913 public static class ParametersContext extends ParserRuleContext { 13914 public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); } 13915 public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); } 13916 public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); } 13917 public TerminalNode ARGUMENT(int i) { 13918 return getToken(JavadocParser.ARGUMENT, i); 13919 } 13920 public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); } 13921 public TerminalNode COMMA(int i) { 13922 return getToken(JavadocParser.COMMA, i); 13923 } 13924 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13925 public TerminalNode WS(int i) { 13926 return getToken(JavadocParser.WS, i); 13927 } 13928 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13929 public TerminalNode NEWLINE(int i) { 13930 return getToken(JavadocParser.NEWLINE, i); 13931 } 13932 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13933 public TerminalNode LEADING_ASTERISK(int i) { 13934 return getToken(JavadocParser.LEADING_ASTERISK, i); 13935 } 13936 public ParametersContext(ParserRuleContext parent, int invokingState) { 13937 super(parent, invokingState); 13938 } 13939 @Override public int getRuleIndex() { return RULE_parameters; } 13940 @Override 13941 public void enterRule(ParseTreeListener listener) { 13942 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParameters(this); 13943 } 13944 @Override 13945 public void exitRule(ParseTreeListener listener) { 13946 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParameters(this); 13947 } 13948 @Override 13949 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13950 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParameters(this); 13951 else return visitor.visitChildren(this); 13952 } 13953 } 13954 13955 public final ParametersContext parameters() throws RecognitionException { 13956 ParametersContext _localctx = new ParametersContext(_ctx, getState()); 13957 enterRule(_localctx, 140, RULE_parameters); 13958 int _la; 13959 try { 13960 enterOuterAlt(_localctx, 1); 13961 { 13962 setState(1599); 13963 match(LEFT_BRACE); 13964 setState(1603); 13965 _errHandler.sync(this); 13966 _la = _input.LA(1); 13967 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) { 13968 { 13969 { 13970 setState(1600); 13971 _la = _input.LA(1); 13972 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) { 13973 _errHandler.recoverInline(this); 13974 } else { 13975 consume(); 13976 } 13977 } 13978 } 13979 setState(1605); 13980 _errHandler.sync(this); 13981 _la = _input.LA(1); 13982 } 13983 setState(1606); 13984 match(RIGHT_BRACE); 13985 } 13986 } 13987 catch (RecognitionException re) { 13988 _localctx.exception = re; 13989 _errHandler.reportError(this, re); 13990 _errHandler.recover(this, re); 13991 } 13992 finally { 13993 exitRule(); 13994 } 13995 return _localctx; 13996 } 13997 13998 public static class JavadocTagContext extends ParserRuleContext { 13999 public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); } 14000 public DescriptionContext description() { 14001 return getRuleContext(DescriptionContext.class,0); 14002 } 14003 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14004 public TerminalNode WS(int i) { 14005 return getToken(JavadocParser.WS, i); 14006 } 14007 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14008 public TerminalNode NEWLINE(int i) { 14009 return getToken(JavadocParser.NEWLINE, i); 14010 } 14011 public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); } 14012 public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); } 14013 public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); } 14014 public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); } 14015 public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); } 14016 public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); } 14017 public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); } 14018 public ReferenceContext reference() { 14019 return getRuleContext(ReferenceContext.class,0); 14020 } 14021 public List<TerminalNode> STRING() { return getTokens(JavadocParser.STRING); } 14022 public TerminalNode STRING(int i) { 14023 return getToken(JavadocParser.STRING, i); 14024 } 14025 public List<HtmlElementContext> htmlElement() { 14026 return getRuleContexts(HtmlElementContext.class); 14027 } 14028 public HtmlElementContext htmlElement(int i) { 14029 return getRuleContext(HtmlElementContext.class,i); 14030 } 14031 public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); } 14032 public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); } 14033 public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); } 14034 public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); } 14035 public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); } 14036 public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); } 14037 public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); } 14038 public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); } 14039 public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); } 14040 public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); } 14041 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 14042 public JavadocTagContext(ParserRuleContext parent, int invokingState) { 14043 super(parent, invokingState); 14044 } 14045 @Override public int getRuleIndex() { return RULE_javadocTag; } 14046 @Override 14047 public void enterRule(ParseTreeListener listener) { 14048 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocTag(this); 14049 } 14050 @Override 14051 public void exitRule(ParseTreeListener listener) { 14052 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocTag(this); 14053 } 14054 @Override 14055 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14056 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocTag(this); 14057 else return visitor.visitChildren(this); 14058 } 14059 } 14060 14061 public final JavadocTagContext javadocTag() throws RecognitionException { 14062 JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState()); 14063 enterRule(_localctx, 142, RULE_javadocTag); 14064 int _la; 14065 try { 14066 int _alt; 14067 setState(1802); 14068 switch (_input.LA(1)) { 14069 case AUTHOR_LITERAL: 14070 enterOuterAlt(_localctx, 1); 14071 { 14072 setState(1608); 14073 match(AUTHOR_LITERAL); 14074 setState(1612); 14075 _errHandler.sync(this); 14076 _alt = getInterpreter().adaptivePredict(_input,135,_ctx); 14077 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14078 if ( _alt==1 ) { 14079 { 14080 { 14081 setState(1609); 14082 _la = _input.LA(1); 14083 if ( !(_la==WS || _la==NEWLINE) ) { 14084 _errHandler.recoverInline(this); 14085 } else { 14086 consume(); 14087 } 14088 } 14089 } 14090 } 14091 setState(1614); 14092 _errHandler.sync(this); 14093 _alt = getInterpreter().adaptivePredict(_input,135,_ctx); 14094 } 14095 setState(1616); 14096 switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) { 14097 case 1: 14098 { 14099 setState(1615); 14100 description(); 14101 } 14102 break; 14103 } 14104 } 14105 break; 14106 case DEPRECATED_LITERAL: 14107 enterOuterAlt(_localctx, 2); 14108 { 14109 setState(1618); 14110 match(DEPRECATED_LITERAL); 14111 setState(1622); 14112 _errHandler.sync(this); 14113 _alt = getInterpreter().adaptivePredict(_input,137,_ctx); 14114 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14115 if ( _alt==1 ) { 14116 { 14117 { 14118 setState(1619); 14119 _la = _input.LA(1); 14120 if ( !(_la==WS || _la==NEWLINE) ) { 14121 _errHandler.recoverInline(this); 14122 } else { 14123 consume(); 14124 } 14125 } 14126 } 14127 } 14128 setState(1624); 14129 _errHandler.sync(this); 14130 _alt = getInterpreter().adaptivePredict(_input,137,_ctx); 14131 } 14132 setState(1626); 14133 switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { 14134 case 1: 14135 { 14136 setState(1625); 14137 description(); 14138 } 14139 break; 14140 } 14141 } 14142 break; 14143 case EXCEPTION_LITERAL: 14144 enterOuterAlt(_localctx, 3); 14145 { 14146 setState(1628); 14147 match(EXCEPTION_LITERAL); 14148 setState(1632); 14149 _errHandler.sync(this); 14150 _alt = getInterpreter().adaptivePredict(_input,139,_ctx); 14151 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14152 if ( _alt==1 ) { 14153 { 14154 { 14155 setState(1629); 14156 _la = _input.LA(1); 14157 if ( !(_la==WS || _la==NEWLINE) ) { 14158 _errHandler.recoverInline(this); 14159 } else { 14160 consume(); 14161 } 14162 } 14163 } 14164 } 14165 setState(1634); 14166 _errHandler.sync(this); 14167 _alt = getInterpreter().adaptivePredict(_input,139,_ctx); 14168 } 14169 setState(1636); 14170 switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) { 14171 case 1: 14172 { 14173 setState(1635); 14174 match(CLASS_NAME); 14175 } 14176 break; 14177 } 14178 setState(1641); 14179 _errHandler.sync(this); 14180 _alt = getInterpreter().adaptivePredict(_input,141,_ctx); 14181 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14182 if ( _alt==1 ) { 14183 { 14184 { 14185 setState(1638); 14186 _la = _input.LA(1); 14187 if ( !(_la==WS || _la==NEWLINE) ) { 14188 _errHandler.recoverInline(this); 14189 } else { 14190 consume(); 14191 } 14192 } 14193 } 14194 } 14195 setState(1643); 14196 _errHandler.sync(this); 14197 _alt = getInterpreter().adaptivePredict(_input,141,_ctx); 14198 } 14199 setState(1645); 14200 switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) { 14201 case 1: 14202 { 14203 setState(1644); 14204 description(); 14205 } 14206 break; 14207 } 14208 } 14209 break; 14210 case PARAM_LITERAL: 14211 enterOuterAlt(_localctx, 4); 14212 { 14213 setState(1647); 14214 match(PARAM_LITERAL); 14215 setState(1651); 14216 _errHandler.sync(this); 14217 _alt = getInterpreter().adaptivePredict(_input,143,_ctx); 14218 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14219 if ( _alt==1 ) { 14220 { 14221 { 14222 setState(1648); 14223 _la = _input.LA(1); 14224 if ( !(_la==WS || _la==NEWLINE) ) { 14225 _errHandler.recoverInline(this); 14226 } else { 14227 consume(); 14228 } 14229 } 14230 } 14231 } 14232 setState(1653); 14233 _errHandler.sync(this); 14234 _alt = getInterpreter().adaptivePredict(_input,143,_ctx); 14235 } 14236 setState(1655); 14237 switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { 14238 case 1: 14239 { 14240 setState(1654); 14241 match(PARAMETER_NAME); 14242 } 14243 break; 14244 } 14245 setState(1660); 14246 _errHandler.sync(this); 14247 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 14248 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14249 if ( _alt==1 ) { 14250 { 14251 { 14252 setState(1657); 14253 _la = _input.LA(1); 14254 if ( !(_la==WS || _la==NEWLINE) ) { 14255 _errHandler.recoverInline(this); 14256 } else { 14257 consume(); 14258 } 14259 } 14260 } 14261 } 14262 setState(1662); 14263 _errHandler.sync(this); 14264 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 14265 } 14266 setState(1664); 14267 switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { 14268 case 1: 14269 { 14270 setState(1663); 14271 description(); 14272 } 14273 break; 14274 } 14275 } 14276 break; 14277 case RETURN_LITERAL: 14278 enterOuterAlt(_localctx, 5); 14279 { 14280 setState(1666); 14281 match(RETURN_LITERAL); 14282 setState(1670); 14283 _errHandler.sync(this); 14284 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 14285 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14286 if ( _alt==1 ) { 14287 { 14288 { 14289 setState(1667); 14290 _la = _input.LA(1); 14291 if ( !(_la==WS || _la==NEWLINE) ) { 14292 _errHandler.recoverInline(this); 14293 } else { 14294 consume(); 14295 } 14296 } 14297 } 14298 } 14299 setState(1672); 14300 _errHandler.sync(this); 14301 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 14302 } 14303 setState(1674); 14304 switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { 14305 case 1: 14306 { 14307 setState(1673); 14308 description(); 14309 } 14310 break; 14311 } 14312 } 14313 break; 14314 case SEE_LITERAL: 14315 enterOuterAlt(_localctx, 6); 14316 { 14317 setState(1676); 14318 match(SEE_LITERAL); 14319 setState(1680); 14320 _errHandler.sync(this); 14321 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 14322 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14323 if ( _alt==1 ) { 14324 { 14325 { 14326 setState(1677); 14327 _la = _input.LA(1); 14328 if ( !(_la==WS || _la==NEWLINE) ) { 14329 _errHandler.recoverInline(this); 14330 } else { 14331 consume(); 14332 } 14333 } 14334 } 14335 } 14336 setState(1682); 14337 _errHandler.sync(this); 14338 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 14339 } 14340 setState(1684); 14341 switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { 14342 case 1: 14343 { 14344 setState(1683); 14345 reference(); 14346 } 14347 break; 14348 } 14349 setState(1690); 14350 _errHandler.sync(this); 14351 _alt = getInterpreter().adaptivePredict(_input,152,_ctx); 14352 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14353 if ( _alt==1 ) { 14354 { 14355 setState(1688); 14356 switch (_input.LA(1)) { 14357 case STRING: 14358 { 14359 setState(1686); 14360 match(STRING); 14361 } 14362 break; 14363 case OPEN: 14364 { 14365 setState(1687); 14366 htmlElement(); 14367 } 14368 break; 14369 default: 14370 throw new NoViableAltException(this); 14371 } 14372 } 14373 } 14374 setState(1692); 14375 _errHandler.sync(this); 14376 _alt = getInterpreter().adaptivePredict(_input,152,_ctx); 14377 } 14378 setState(1696); 14379 _errHandler.sync(this); 14380 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 14381 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14382 if ( _alt==1 ) { 14383 { 14384 { 14385 setState(1693); 14386 _la = _input.LA(1); 14387 if ( !(_la==WS || _la==NEWLINE) ) { 14388 _errHandler.recoverInline(this); 14389 } else { 14390 consume(); 14391 } 14392 } 14393 } 14394 } 14395 setState(1698); 14396 _errHandler.sync(this); 14397 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 14398 } 14399 setState(1700); 14400 switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { 14401 case 1: 14402 { 14403 setState(1699); 14404 description(); 14405 } 14406 break; 14407 } 14408 } 14409 break; 14410 case SERIAL_LITERAL: 14411 enterOuterAlt(_localctx, 7); 14412 { 14413 setState(1702); 14414 match(SERIAL_LITERAL); 14415 setState(1706); 14416 _errHandler.sync(this); 14417 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 14418 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14419 if ( _alt==1 ) { 14420 { 14421 { 14422 setState(1703); 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(1708); 14433 _errHandler.sync(this); 14434 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 14435 } 14436 setState(1710); 14437 switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { 14438 case 1: 14439 { 14440 setState(1709); 14441 _la = _input.LA(1); 14442 if ( !(_la==LITERAL_INCLUDE || _la==LITERAL_EXCLUDE) ) { 14443 _errHandler.recoverInline(this); 14444 } else { 14445 consume(); 14446 } 14447 } 14448 break; 14449 } 14450 setState(1713); 14451 switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { 14452 case 1: 14453 { 14454 setState(1712); 14455 description(); 14456 } 14457 break; 14458 } 14459 } 14460 break; 14461 case SERIAL_DATA_LITERAL: 14462 enterOuterAlt(_localctx, 8); 14463 { 14464 setState(1715); 14465 match(SERIAL_DATA_LITERAL); 14466 setState(1719); 14467 _errHandler.sync(this); 14468 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14469 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14470 if ( _alt==1 ) { 14471 { 14472 { 14473 setState(1716); 14474 _la = _input.LA(1); 14475 if ( !(_la==WS || _la==NEWLINE) ) { 14476 _errHandler.recoverInline(this); 14477 } else { 14478 consume(); 14479 } 14480 } 14481 } 14482 } 14483 setState(1721); 14484 _errHandler.sync(this); 14485 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14486 } 14487 setState(1723); 14488 switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) { 14489 case 1: 14490 { 14491 setState(1722); 14492 description(); 14493 } 14494 break; 14495 } 14496 } 14497 break; 14498 case SERIAL_FIELD_LITERAL: 14499 enterOuterAlt(_localctx, 9); 14500 { 14501 setState(1725); 14502 match(SERIAL_FIELD_LITERAL); 14503 setState(1729); 14504 _errHandler.sync(this); 14505 _alt = getInterpreter().adaptivePredict(_input,160,_ctx); 14506 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14507 if ( _alt==1 ) { 14508 { 14509 { 14510 setState(1726); 14511 _la = _input.LA(1); 14512 if ( !(_la==WS || _la==NEWLINE) ) { 14513 _errHandler.recoverInline(this); 14514 } else { 14515 consume(); 14516 } 14517 } 14518 } 14519 } 14520 setState(1731); 14521 _errHandler.sync(this); 14522 _alt = getInterpreter().adaptivePredict(_input,160,_ctx); 14523 } 14524 setState(1733); 14525 switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) { 14526 case 1: 14527 { 14528 setState(1732); 14529 match(FIELD_NAME); 14530 } 14531 break; 14532 } 14533 setState(1738); 14534 _errHandler.sync(this); 14535 _alt = getInterpreter().adaptivePredict(_input,162,_ctx); 14536 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14537 if ( _alt==1 ) { 14538 { 14539 { 14540 setState(1735); 14541 _la = _input.LA(1); 14542 if ( !(_la==WS || _la==NEWLINE) ) { 14543 _errHandler.recoverInline(this); 14544 } else { 14545 consume(); 14546 } 14547 } 14548 } 14549 } 14550 setState(1740); 14551 _errHandler.sync(this); 14552 _alt = getInterpreter().adaptivePredict(_input,162,_ctx); 14553 } 14554 setState(1742); 14555 switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) { 14556 case 1: 14557 { 14558 setState(1741); 14559 match(FIELD_TYPE); 14560 } 14561 break; 14562 } 14563 setState(1747); 14564 _errHandler.sync(this); 14565 _alt = getInterpreter().adaptivePredict(_input,164,_ctx); 14566 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14567 if ( _alt==1 ) { 14568 { 14569 { 14570 setState(1744); 14571 _la = _input.LA(1); 14572 if ( !(_la==WS || _la==NEWLINE) ) { 14573 _errHandler.recoverInline(this); 14574 } else { 14575 consume(); 14576 } 14577 } 14578 } 14579 } 14580 setState(1749); 14581 _errHandler.sync(this); 14582 _alt = getInterpreter().adaptivePredict(_input,164,_ctx); 14583 } 14584 setState(1751); 14585 switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) { 14586 case 1: 14587 { 14588 setState(1750); 14589 description(); 14590 } 14591 break; 14592 } 14593 } 14594 break; 14595 case SINCE_LITERAL: 14596 enterOuterAlt(_localctx, 10); 14597 { 14598 setState(1753); 14599 match(SINCE_LITERAL); 14600 setState(1757); 14601 _errHandler.sync(this); 14602 _alt = getInterpreter().adaptivePredict(_input,166,_ctx); 14603 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14604 if ( _alt==1 ) { 14605 { 14606 { 14607 setState(1754); 14608 _la = _input.LA(1); 14609 if ( !(_la==WS || _la==NEWLINE) ) { 14610 _errHandler.recoverInline(this); 14611 } else { 14612 consume(); 14613 } 14614 } 14615 } 14616 } 14617 setState(1759); 14618 _errHandler.sync(this); 14619 _alt = getInterpreter().adaptivePredict(_input,166,_ctx); 14620 } 14621 setState(1761); 14622 switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { 14623 case 1: 14624 { 14625 setState(1760); 14626 description(); 14627 } 14628 break; 14629 } 14630 } 14631 break; 14632 case THROWS_LITERAL: 14633 enterOuterAlt(_localctx, 11); 14634 { 14635 setState(1763); 14636 match(THROWS_LITERAL); 14637 setState(1767); 14638 _errHandler.sync(this); 14639 _alt = getInterpreter().adaptivePredict(_input,168,_ctx); 14640 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14641 if ( _alt==1 ) { 14642 { 14643 { 14644 setState(1764); 14645 _la = _input.LA(1); 14646 if ( !(_la==WS || _la==NEWLINE) ) { 14647 _errHandler.recoverInline(this); 14648 } else { 14649 consume(); 14650 } 14651 } 14652 } 14653 } 14654 setState(1769); 14655 _errHandler.sync(this); 14656 _alt = getInterpreter().adaptivePredict(_input,168,_ctx); 14657 } 14658 setState(1771); 14659 switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) { 14660 case 1: 14661 { 14662 setState(1770); 14663 match(CLASS_NAME); 14664 } 14665 break; 14666 } 14667 setState(1776); 14668 _errHandler.sync(this); 14669 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14670 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14671 if ( _alt==1 ) { 14672 { 14673 { 14674 setState(1773); 14675 _la = _input.LA(1); 14676 if ( !(_la==WS || _la==NEWLINE) ) { 14677 _errHandler.recoverInline(this); 14678 } else { 14679 consume(); 14680 } 14681 } 14682 } 14683 } 14684 setState(1778); 14685 _errHandler.sync(this); 14686 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14687 } 14688 setState(1780); 14689 switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) { 14690 case 1: 14691 { 14692 setState(1779); 14693 description(); 14694 } 14695 break; 14696 } 14697 } 14698 break; 14699 case VERSION_LITERAL: 14700 enterOuterAlt(_localctx, 12); 14701 { 14702 setState(1782); 14703 match(VERSION_LITERAL); 14704 setState(1786); 14705 _errHandler.sync(this); 14706 _alt = getInterpreter().adaptivePredict(_input,172,_ctx); 14707 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14708 if ( _alt==1 ) { 14709 { 14710 { 14711 setState(1783); 14712 _la = _input.LA(1); 14713 if ( !(_la==WS || _la==NEWLINE) ) { 14714 _errHandler.recoverInline(this); 14715 } else { 14716 consume(); 14717 } 14718 } 14719 } 14720 } 14721 setState(1788); 14722 _errHandler.sync(this); 14723 _alt = getInterpreter().adaptivePredict(_input,172,_ctx); 14724 } 14725 setState(1790); 14726 switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) { 14727 case 1: 14728 { 14729 setState(1789); 14730 description(); 14731 } 14732 break; 14733 } 14734 } 14735 break; 14736 case CUSTOM_NAME: 14737 enterOuterAlt(_localctx, 13); 14738 { 14739 setState(1792); 14740 match(CUSTOM_NAME); 14741 setState(1796); 14742 _errHandler.sync(this); 14743 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 14744 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14745 if ( _alt==1 ) { 14746 { 14747 { 14748 setState(1793); 14749 _la = _input.LA(1); 14750 if ( !(_la==WS || _la==NEWLINE) ) { 14751 _errHandler.recoverInline(this); 14752 } else { 14753 consume(); 14754 } 14755 } 14756 } 14757 } 14758 setState(1798); 14759 _errHandler.sync(this); 14760 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 14761 } 14762 setState(1800); 14763 switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) { 14764 case 1: 14765 { 14766 setState(1799); 14767 description(); 14768 } 14769 break; 14770 } 14771 } 14772 break; 14773 default: 14774 throw new NoViableAltException(this); 14775 } 14776 } 14777 catch (RecognitionException re) { 14778 _localctx.exception = re; 14779 _errHandler.reportError(this, re); 14780 _errHandler.recover(this, re); 14781 } 14782 finally { 14783 exitRule(); 14784 } 14785 return _localctx; 14786 } 14787 14788 public static class JavadocInlineTagContext extends ParserRuleContext { 14789 public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); } 14790 public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); } 14791 public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); } 14792 public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); } 14793 public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); } 14794 public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); } 14795 public ReferenceContext reference() { 14796 return getRuleContext(ReferenceContext.class,0); 14797 } 14798 public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); } 14799 public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); } 14800 public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); } 14801 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 14802 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14803 public TerminalNode WS(int i) { 14804 return getToken(JavadocParser.WS, i); 14805 } 14806 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14807 public TerminalNode NEWLINE(int i) { 14808 return getToken(JavadocParser.NEWLINE, i); 14809 } 14810 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14811 public TerminalNode LEADING_ASTERISK(int i) { 14812 return getToken(JavadocParser.LEADING_ASTERISK, i); 14813 } 14814 public List<TextContext> text() { 14815 return getRuleContexts(TextContext.class); 14816 } 14817 public TextContext text(int i) { 14818 return getRuleContext(TextContext.class,i); 14819 } 14820 public DescriptionContext description() { 14821 return getRuleContext(DescriptionContext.class,0); 14822 } 14823 public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) { 14824 super(parent, invokingState); 14825 } 14826 @Override public int getRuleIndex() { return RULE_javadocInlineTag; } 14827 @Override 14828 public void enterRule(ParseTreeListener listener) { 14829 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocInlineTag(this); 14830 } 14831 @Override 14832 public void exitRule(ParseTreeListener listener) { 14833 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocInlineTag(this); 14834 } 14835 @Override 14836 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14837 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocInlineTag(this); 14838 else return visitor.visitChildren(this); 14839 } 14840 } 14841 14842 public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException { 14843 JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState()); 14844 enterRule(_localctx, 144, RULE_javadocInlineTag); 14845 int _la; 14846 try { 14847 int _alt; 14848 enterOuterAlt(_localctx, 1); 14849 { 14850 setState(1804); 14851 match(JAVADOC_INLINE_TAG_START); 14852 setState(1880); 14853 switch (_input.LA(1)) { 14854 case CODE_LITERAL: 14855 { 14856 setState(1805); 14857 match(CODE_LITERAL); 14858 setState(1812); 14859 _errHandler.sync(this); 14860 _la = _input.LA(1); 14861 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 14862 { 14863 setState(1810); 14864 switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) { 14865 case 1: 14866 { 14867 setState(1806); 14868 match(WS); 14869 } 14870 break; 14871 case 2: 14872 { 14873 setState(1807); 14874 match(NEWLINE); 14875 } 14876 break; 14877 case 3: 14878 { 14879 setState(1808); 14880 match(LEADING_ASTERISK); 14881 } 14882 break; 14883 case 4: 14884 { 14885 setState(1809); 14886 text(); 14887 } 14888 break; 14889 } 14890 } 14891 setState(1814); 14892 _errHandler.sync(this); 14893 _la = _input.LA(1); 14894 } 14895 } 14896 break; 14897 case DOC_ROOT_LITERAL: 14898 { 14899 setState(1815); 14900 match(DOC_ROOT_LITERAL); 14901 setState(1819); 14902 _errHandler.sync(this); 14903 _la = _input.LA(1); 14904 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 14905 { 14906 { 14907 setState(1816); 14908 _la = _input.LA(1); 14909 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14910 _errHandler.recoverInline(this); 14911 } else { 14912 consume(); 14913 } 14914 } 14915 } 14916 setState(1821); 14917 _errHandler.sync(this); 14918 _la = _input.LA(1); 14919 } 14920 } 14921 break; 14922 case INHERIT_DOC_LITERAL: 14923 { 14924 setState(1822); 14925 match(INHERIT_DOC_LITERAL); 14926 setState(1826); 14927 _errHandler.sync(this); 14928 _la = _input.LA(1); 14929 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 14930 { 14931 { 14932 setState(1823); 14933 _la = _input.LA(1); 14934 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14935 _errHandler.recoverInline(this); 14936 } else { 14937 consume(); 14938 } 14939 } 14940 } 14941 setState(1828); 14942 _errHandler.sync(this); 14943 _la = _input.LA(1); 14944 } 14945 } 14946 break; 14947 case LINK_LITERAL: 14948 { 14949 setState(1829); 14950 match(LINK_LITERAL); 14951 setState(1833); 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(1830); 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(1835); 14967 _errHandler.sync(this); 14968 _la = _input.LA(1); 14969 } 14970 setState(1836); 14971 reference(); 14972 setState(1838); 14973 switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { 14974 case 1: 14975 { 14976 setState(1837); 14977 description(); 14978 } 14979 break; 14980 } 14981 } 14982 break; 14983 case LINKPLAIN_LITERAL: 14984 { 14985 setState(1840); 14986 match(LINKPLAIN_LITERAL); 14987 setState(1844); 14988 _errHandler.sync(this); 14989 _la = _input.LA(1); 14990 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 14991 { 14992 { 14993 setState(1841); 14994 _la = _input.LA(1); 14995 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14996 _errHandler.recoverInline(this); 14997 } else { 14998 consume(); 14999 } 15000 } 15001 } 15002 setState(1846); 15003 _errHandler.sync(this); 15004 _la = _input.LA(1); 15005 } 15006 setState(1847); 15007 reference(); 15008 setState(1849); 15009 switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) { 15010 case 1: 15011 { 15012 setState(1848); 15013 description(); 15014 } 15015 break; 15016 } 15017 } 15018 break; 15019 case LITERAL_LITERAL: 15020 { 15021 setState(1851); 15022 match(LITERAL_LITERAL); 15023 setState(1858); 15024 _errHandler.sync(this); 15025 _la = _input.LA(1); 15026 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15027 { 15028 setState(1856); 15029 switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) { 15030 case 1: 15031 { 15032 setState(1852); 15033 match(WS); 15034 } 15035 break; 15036 case 2: 15037 { 15038 setState(1853); 15039 match(NEWLINE); 15040 } 15041 break; 15042 case 3: 15043 { 15044 setState(1854); 15045 match(LEADING_ASTERISK); 15046 } 15047 break; 15048 case 4: 15049 { 15050 setState(1855); 15051 text(); 15052 } 15053 break; 15054 } 15055 } 15056 setState(1860); 15057 _errHandler.sync(this); 15058 _la = _input.LA(1); 15059 } 15060 } 15061 break; 15062 case VALUE_LITERAL: 15063 { 15064 setState(1861); 15065 match(VALUE_LITERAL); 15066 setState(1865); 15067 _errHandler.sync(this); 15068 _la = _input.LA(1); 15069 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15070 { 15071 { 15072 setState(1862); 15073 _la = _input.LA(1); 15074 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15075 _errHandler.recoverInline(this); 15076 } else { 15077 consume(); 15078 } 15079 } 15080 } 15081 setState(1867); 15082 _errHandler.sync(this); 15083 _la = _input.LA(1); 15084 } 15085 setState(1869); 15086 _la = _input.LA(1); 15087 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << DOT) | (1L << HASH) | (1L << CLASS) | (1L << MEMBER))) != 0)) { 15088 { 15089 setState(1868); 15090 reference(); 15091 } 15092 } 15093 15094 } 15095 break; 15096 case CUSTOM_NAME: 15097 { 15098 setState(1871); 15099 match(CUSTOM_NAME); 15100 setState(1873); 15101 _errHandler.sync(this); 15102 _alt = 1; 15103 do { 15104 switch (_alt) { 15105 case 1: 15106 { 15107 { 15108 setState(1872); 15109 _la = _input.LA(1); 15110 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15111 _errHandler.recoverInline(this); 15112 } else { 15113 consume(); 15114 } 15115 } 15116 } 15117 break; 15118 default: 15119 throw new NoViableAltException(this); 15120 } 15121 setState(1875); 15122 _errHandler.sync(this); 15123 _alt = getInterpreter().adaptivePredict(_input,189,_ctx); 15124 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15125 setState(1878); 15126 switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) { 15127 case 1: 15128 { 15129 setState(1877); 15130 description(); 15131 } 15132 break; 15133 } 15134 } 15135 break; 15136 default: 15137 throw new NoViableAltException(this); 15138 } 15139 setState(1882); 15140 match(JAVADOC_INLINE_TAG_END); 15141 } 15142 } 15143 catch (RecognitionException re) { 15144 _localctx.exception = re; 15145 _errHandler.reportError(this, re); 15146 _errHandler.recover(this, re); 15147 } 15148 finally { 15149 exitRule(); 15150 } 15151 return _localctx; 15152 } 15153 15154 public static class HtmlCommentContext extends ParserRuleContext { 15155 public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); } 15156 public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); } 15157 public List<TextContext> text() { 15158 return getRuleContexts(TextContext.class); 15159 } 15160 public TextContext text(int i) { 15161 return getRuleContext(TextContext.class,i); 15162 } 15163 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15164 public TerminalNode NEWLINE(int i) { 15165 return getToken(JavadocParser.NEWLINE, i); 15166 } 15167 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15168 public TerminalNode LEADING_ASTERISK(int i) { 15169 return getToken(JavadocParser.LEADING_ASTERISK, i); 15170 } 15171 public HtmlCommentContext(ParserRuleContext parent, int invokingState) { 15172 super(parent, invokingState); 15173 } 15174 @Override public int getRuleIndex() { return RULE_htmlComment; } 15175 @Override 15176 public void enterRule(ParseTreeListener listener) { 15177 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlComment(this); 15178 } 15179 @Override 15180 public void exitRule(ParseTreeListener listener) { 15181 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlComment(this); 15182 } 15183 @Override 15184 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15185 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlComment(this); 15186 else return visitor.visitChildren(this); 15187 } 15188 } 15189 15190 public final HtmlCommentContext htmlComment() throws RecognitionException { 15191 HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState()); 15192 enterRule(_localctx, 146, RULE_htmlComment); 15193 int _la; 15194 try { 15195 enterOuterAlt(_localctx, 1); 15196 { 15197 setState(1884); 15198 match(HTML_COMMENT_START); 15199 setState(1890); 15200 _errHandler.sync(this); 15201 _la = _input.LA(1); 15202 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15203 { 15204 setState(1888); 15205 switch (_input.LA(1)) { 15206 case WS: 15207 case CHAR: 15208 { 15209 setState(1885); 15210 text(); 15211 } 15212 break; 15213 case NEWLINE: 15214 { 15215 setState(1886); 15216 match(NEWLINE); 15217 } 15218 break; 15219 case LEADING_ASTERISK: 15220 { 15221 setState(1887); 15222 match(LEADING_ASTERISK); 15223 } 15224 break; 15225 default: 15226 throw new NoViableAltException(this); 15227 } 15228 } 15229 setState(1892); 15230 _errHandler.sync(this); 15231 _la = _input.LA(1); 15232 } 15233 setState(1893); 15234 match(HTML_COMMENT_END); 15235 } 15236 } 15237 catch (RecognitionException re) { 15238 _localctx.exception = re; 15239 _errHandler.reportError(this, re); 15240 _errHandler.recover(this, re); 15241 } 15242 finally { 15243 exitRule(); 15244 } 15245 return _localctx; 15246 } 15247 15248 public static class TextContext extends ParserRuleContext { 15249 public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); } 15250 public TerminalNode CHAR(int i) { 15251 return getToken(JavadocParser.CHAR, i); 15252 } 15253 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15254 public TerminalNode WS(int i) { 15255 return getToken(JavadocParser.WS, i); 15256 } 15257 public TextContext(ParserRuleContext parent, int invokingState) { 15258 super(parent, invokingState); 15259 } 15260 @Override public int getRuleIndex() { return RULE_text; } 15261 @Override 15262 public void enterRule(ParseTreeListener listener) { 15263 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterText(this); 15264 } 15265 @Override 15266 public void exitRule(ParseTreeListener listener) { 15267 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitText(this); 15268 } 15269 @Override 15270 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15271 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitText(this); 15272 else return visitor.visitChildren(this); 15273 } 15274 } 15275 15276 public final TextContext text() throws RecognitionException { 15277 TextContext _localctx = new TextContext(_ctx, getState()); 15278 enterRule(_localctx, 148, RULE_text); 15279 int _la; 15280 try { 15281 int _alt; 15282 enterOuterAlt(_localctx, 1); 15283 { 15284 setState(1896); 15285 _errHandler.sync(this); 15286 _alt = 1; 15287 do { 15288 switch (_alt) { 15289 case 1: 15290 { 15291 { 15292 setState(1895); 15293 _la = _input.LA(1); 15294 if ( !(_la==WS || _la==CHAR) ) { 15295 _errHandler.recoverInline(this); 15296 } else { 15297 consume(); 15298 } 15299 } 15300 } 15301 break; 15302 default: 15303 throw new NoViableAltException(this); 15304 } 15305 setState(1898); 15306 _errHandler.sync(this); 15307 _alt = getInterpreter().adaptivePredict(_input,194,_ctx); 15308 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15309 } 15310 } 15311 catch (RecognitionException re) { 15312 _localctx.exception = re; 15313 _errHandler.reportError(this, re); 15314 _errHandler.recover(this, re); 15315 } 15316 finally { 15317 exitRule(); 15318 } 15319 return _localctx; 15320 } 15321 15322 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { 15323 switch (ruleIndex) { 15324 case 0: 15325 return javadoc_sempred((JavadocContext)_localctx, predIndex); 15326 case 5: 15327 return htmlTag_sempred((HtmlTagContext)_localctx, predIndex); 15328 case 8: 15329 return paragraph_sempred((ParagraphContext)_localctx, predIndex); 15330 case 11: 15331 return li_sempred((LiContext)_localctx, predIndex); 15332 case 14: 15333 return tr_sempred((TrContext)_localctx, predIndex); 15334 case 17: 15335 return td_sempred((TdContext)_localctx, predIndex); 15336 case 20: 15337 return th_sempred((ThContext)_localctx, predIndex); 15338 case 23: 15339 return body_sempred((BodyContext)_localctx, predIndex); 15340 case 26: 15341 return colgroup_sempred((ColgroupContext)_localctx, predIndex); 15342 case 29: 15343 return dd_sempred((DdContext)_localctx, predIndex); 15344 case 32: 15345 return dt_sempred((DtContext)_localctx, predIndex); 15346 case 35: 15347 return head_sempred((HeadContext)_localctx, predIndex); 15348 case 38: 15349 return html_sempred((HtmlContext)_localctx, predIndex); 15350 case 41: 15351 return option_sempred((OptionContext)_localctx, predIndex); 15352 case 44: 15353 return tbody_sempred((TbodyContext)_localctx, predIndex); 15354 case 47: 15355 return tfoot_sempred((TfootContext)_localctx, predIndex); 15356 case 50: 15357 return thead_sempred((TheadContext)_localctx, predIndex); 15358 case 68: 15359 return description_sempred((DescriptionContext)_localctx, predIndex); 15360 } 15361 return true; 15362 } 15363 private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) { 15364 switch (predIndex) { 15365 case 0: 15366 return !isNextJavadocTag(); 15367 } 15368 return true; 15369 } 15370 private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) { 15371 switch (predIndex) { 15372 case 1: 15373 return !isNextJavadocTag(); 15374 case 2: 15375 return !isNextJavadocTag(); 15376 } 15377 return true; 15378 } 15379 private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) { 15380 switch (predIndex) { 15381 case 3: 15382 return !isNextJavadocTag(); 15383 } 15384 return true; 15385 } 15386 private boolean li_sempred(LiContext _localctx, int predIndex) { 15387 switch (predIndex) { 15388 case 4: 15389 return !isNextJavadocTag(); 15390 } 15391 return true; 15392 } 15393 private boolean tr_sempred(TrContext _localctx, int predIndex) { 15394 switch (predIndex) { 15395 case 5: 15396 return !isNextJavadocTag(); 15397 } 15398 return true; 15399 } 15400 private boolean td_sempred(TdContext _localctx, int predIndex) { 15401 switch (predIndex) { 15402 case 6: 15403 return !isNextJavadocTag(); 15404 } 15405 return true; 15406 } 15407 private boolean th_sempred(ThContext _localctx, int predIndex) { 15408 switch (predIndex) { 15409 case 7: 15410 return !isNextJavadocTag(); 15411 } 15412 return true; 15413 } 15414 private boolean body_sempred(BodyContext _localctx, int predIndex) { 15415 switch (predIndex) { 15416 case 8: 15417 return !isNextJavadocTag(); 15418 } 15419 return true; 15420 } 15421 private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) { 15422 switch (predIndex) { 15423 case 9: 15424 return !isNextJavadocTag(); 15425 } 15426 return true; 15427 } 15428 private boolean dd_sempred(DdContext _localctx, int predIndex) { 15429 switch (predIndex) { 15430 case 10: 15431 return !isNextJavadocTag(); 15432 } 15433 return true; 15434 } 15435 private boolean dt_sempred(DtContext _localctx, int predIndex) { 15436 switch (predIndex) { 15437 case 11: 15438 return !isNextJavadocTag(); 15439 } 15440 return true; 15441 } 15442 private boolean head_sempred(HeadContext _localctx, int predIndex) { 15443 switch (predIndex) { 15444 case 12: 15445 return !isNextJavadocTag(); 15446 } 15447 return true; 15448 } 15449 private boolean html_sempred(HtmlContext _localctx, int predIndex) { 15450 switch (predIndex) { 15451 case 13: 15452 return !isNextJavadocTag(); 15453 } 15454 return true; 15455 } 15456 private boolean option_sempred(OptionContext _localctx, int predIndex) { 15457 switch (predIndex) { 15458 case 14: 15459 return !isNextJavadocTag(); 15460 } 15461 return true; 15462 } 15463 private boolean tbody_sempred(TbodyContext _localctx, int predIndex) { 15464 switch (predIndex) { 15465 case 15: 15466 return !isNextJavadocTag(); 15467 } 15468 return true; 15469 } 15470 private boolean tfoot_sempred(TfootContext _localctx, int predIndex) { 15471 switch (predIndex) { 15472 case 16: 15473 return !isNextJavadocTag(); 15474 } 15475 return true; 15476 } 15477 private boolean thead_sempred(TheadContext _localctx, int predIndex) { 15478 switch (predIndex) { 15479 case 17: 15480 return !isNextJavadocTag(); 15481 } 15482 return true; 15483 } 15484 private boolean description_sempred(DescriptionContext _localctx, int predIndex) { 15485 switch (predIndex) { 15486 case 18: 15487 return !isNextJavadocTag(); 15488 } 15489 return true; 15490 } 15491 15492 public static final String _serializedATN = 15493 "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3]\u076f\4\2\t\2\4"+ 15494 "\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"+ 15495 "\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"+ 15496 "\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"+ 15497 "\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!"+ 15498 "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ 15499 ",\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"+ 15500 "\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="+ 15501 "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ 15502 "\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"+ 15503 "\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"+ 15504 "\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"+ 15505 "\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"+ 15506 "\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"+ 15507 "\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"+ 15508 "\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"+ 15509 "\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"+ 15510 "\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"+ 15511 "\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"+ 15512 "\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"+ 15513 "\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"+ 15514 "\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"+ 15515 "\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"+ 15516 "\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"+ 15517 "\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"+ 15518 "\13\3\13\3\13\3\13\3\13\3\13\7\13\u0180\n\13\f\13\16\13\u0183\13\13\3"+ 15519 "\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"+ 15520 "\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"+ 15521 "\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"+ 15522 "\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"+ 15523 "\3\16\3\16\7\16\u01c5\n\16\f\16\16\16\u01c8\13\16\3\16\3\16\3\17\3\17"+ 15524 "\3\17\3\17\7\17\u01d0\n\17\f\17\16\17\u01d3\13\17\3\17\3\17\3\20\3\20"+ 15525 "\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"+ 15526 "\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"+ 15527 "\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"+ 15528 "\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"+ 15529 "\21\u020d\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0215\n\22\f\22\16"+ 15530 "\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"+ 15531 "\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"+ 15532 "\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"+ 15533 "\3\23\7\23\u0242\n\23\f\23\16\23\u0245\13\23\3\23\3\23\3\24\3\24\3\24"+ 15534 "\3\24\3\24\3\24\7\24\u024f\n\24\f\24\16\24\u0252\13\24\3\24\3\24\3\25"+ 15535 "\3\25\3\25\3\25\7\25\u025a\n\25\f\25\16\25\u025d\13\25\3\25\3\25\3\26"+ 15536 "\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"+ 15537 "\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"+ 15538 "\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"+ 15539 "\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"+ 15540 "\f\27\16\27\u0297\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u029f\n\30"+ 15541 "\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"+ 15542 "\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"+ 15543 "\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"+ 15544 "\31\3\31\3\31\7\31\u02cc\n\31\f\31\16\31\u02cf\13\31\3\31\3\31\3\32\3"+ 15545 "\32\3\32\3\32\3\32\3\32\7\32\u02d9\n\32\f\32\16\32\u02dc\13\32\3\32\3"+ 15546 "\32\3\33\3\33\3\33\3\33\7\33\u02e4\n\33\f\33\16\33\u02e7\13\33\3\33\3"+ 15547 "\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"+ 15548 "\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"+ 15549 "\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"+ 15550 "\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"+ 15551 "\n\35\f\35\16\35\u0321\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0329"+ 15552 "\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"+ 15553 "\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"+ 15554 "\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"+ 15555 "\37\3\37\3\37\3\37\7\37\u0356\n\37\f\37\16\37\u0359\13\37\3\37\3\37\3"+ 15556 " \3 \3 \3 \3 \3 \7 \u0363\n \f \16 \u0366\13 \3 \3 \3!\3!\3!\3!\7!\u036e"+ 15557 "\n!\f!\16!\u0371\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+ 15558 "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+ 15559 "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u039b\n\"\f\"\16\"\u039e\13"+ 15560 "\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u03a8\n#\f#\16#\u03ab\13#\3#\3#\3$\3$"+ 15561 "\3$\3$\7$\u03b3\n$\f$\16$\u03b6\13$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 15562 "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 15563 "%\3%\3%\3%\3%\3%\7%\u03e0\n%\f%\16%\u03e3\13%\3%\3%\3&\3&\3&\3&\3&\3&"+ 15564 "\7&\u03ed\n&\f&\16&\u03f0\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u03f8\n\'\f\'"+ 15565 "\16\'\u03fb\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+ 15566 "\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+ 15567 "\7(\u0425\n(\f(\16(\u0428\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u0432\n)\f)\16"+ 15568 ")\u0435\13)\3)\3)\3*\3*\3*\3*\7*\u043d\n*\f*\16*\u0440\13*\3*\3*\3+\3"+ 15569 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3"+ 15570 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\7+\u046a\n+\f+\16+\u046d\13+"+ 15571 "\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0477\n,\f,\16,\u047a\13,\3,\3,\3-\3-\3-\3"+ 15572 "-\7-\u0482\n-\f-\16-\u0485\13-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+ 15573 "\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+ 15574 "\3.\3.\3.\3.\7.\u04af\n.\f.\16.\u04b2\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u04bc"+ 15575 "\n/\f/\16/\u04bf\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u04c7\n\60\f\60\16"+ 15576 "\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"+ 15577 "\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"+ 15578 "\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"+ 15579 "\3\61\7\61\u04f4\n\61\f\61\16\61\u04f7\13\61\3\61\3\61\3\62\3\62\3\62"+ 15580 "\3\62\3\62\3\62\7\62\u0501\n\62\f\62\16\62\u0504\13\62\3\62\3\62\3\63"+ 15581 "\3\63\3\63\3\63\7\63\u050c\n\63\f\63\16\63\u050f\13\63\3\63\3\63\3\64"+ 15582 "\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"+ 15583 "\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"+ 15584 "\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"+ 15585 "\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"+ 15586 "\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"+ 15587 "\3\66\7\66\u0557\n\66\f\66\16\66\u055a\13\66\3\66\3\66\3\67\3\67\3\67"+ 15588 "\3\67\3\67\3\67\7\67\u0564\n\67\f\67\16\67\u0567\13\67\3\67\3\67\38\3"+ 15589 "8\38\38\38\38\78\u0571\n8\f8\168\u0574\138\38\38\39\39\39\39\39\39\79"+ 15590 "\u057e\n9\f9\169\u0581\139\39\39\3:\3:\3:\3:\3:\3:\7:\u058b\n:\f:\16:"+ 15591 "\u058e\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0598\n;\f;\16;\u059b\13;\3;\3;"+ 15592 "\3<\3<\3<\3<\3<\3<\7<\u05a5\n<\f<\16<\u05a8\13<\3<\3<\3=\3=\3=\3=\3=\3"+ 15593 "=\7=\u05b2\n=\f=\16=\u05b5\13=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u05bf\n>\f>"+ 15594 "\16>\u05c2\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u05cc\n?\f?\16?\u05cf\13?\3"+ 15595 "?\3?\3@\3@\3@\3@\3@\3@\7@\u05d9\n@\f@\16@\u05dc\13@\3@\3@\3A\3A\3A\3A"+ 15596 "\3A\3A\7A\u05e6\nA\fA\16A\u05e9\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u05f3\n"+ 15597 "B\fB\16B\u05f6\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u0600\nC\fC\16C\u0603\13"+ 15598 "C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u0617\nF\r"+ 15599 "F\16F\u0618\3G\3G\7G\u061d\nG\fG\16G\u0620\13G\3G\5G\u0623\nG\3G\5G\u0626"+ 15600 "\nG\3G\5G\u0629\nG\3G\6G\u062c\nG\rG\16G\u062d\3G\5G\u0631\nG\3G\5G\u0634"+ 15601 "\nG\3G\5G\u0637\nG\3G\5G\u063a\nG\3G\3G\5G\u063e\nG\5G\u0640\nG\3H\3H"+ 15602 "\7H\u0644\nH\fH\16H\u0647\13H\3H\3H\3I\3I\7I\u064d\nI\fI\16I\u0650\13"+ 15603 "I\3I\5I\u0653\nI\3I\3I\7I\u0657\nI\fI\16I\u065a\13I\3I\5I\u065d\nI\3I"+ 15604 "\3I\7I\u0661\nI\fI\16I\u0664\13I\3I\5I\u0667\nI\3I\7I\u066a\nI\fI\16I"+ 15605 "\u066d\13I\3I\5I\u0670\nI\3I\3I\7I\u0674\nI\fI\16I\u0677\13I\3I\5I\u067a"+ 15606 "\nI\3I\7I\u067d\nI\fI\16I\u0680\13I\3I\5I\u0683\nI\3I\3I\7I\u0687\nI\f"+ 15607 "I\16I\u068a\13I\3I\5I\u068d\nI\3I\3I\7I\u0691\nI\fI\16I\u0694\13I\3I\5"+ 15608 "I\u0697\nI\3I\3I\7I\u069b\nI\fI\16I\u069e\13I\3I\7I\u06a1\nI\fI\16I\u06a4"+ 15609 "\13I\3I\5I\u06a7\nI\3I\3I\7I\u06ab\nI\fI\16I\u06ae\13I\3I\5I\u06b1\nI"+ 15610 "\3I\5I\u06b4\nI\3I\3I\7I\u06b8\nI\fI\16I\u06bb\13I\3I\5I\u06be\nI\3I\3"+ 15611 "I\7I\u06c2\nI\fI\16I\u06c5\13I\3I\5I\u06c8\nI\3I\7I\u06cb\nI\fI\16I\u06ce"+ 15612 "\13I\3I\5I\u06d1\nI\3I\7I\u06d4\nI\fI\16I\u06d7\13I\3I\5I\u06da\nI\3I"+ 15613 "\3I\7I\u06de\nI\fI\16I\u06e1\13I\3I\5I\u06e4\nI\3I\3I\7I\u06e8\nI\fI\16"+ 15614 "I\u06eb\13I\3I\5I\u06ee\nI\3I\7I\u06f1\nI\fI\16I\u06f4\13I\3I\5I\u06f7"+ 15615 "\nI\3I\3I\7I\u06fb\nI\fI\16I\u06fe\13I\3I\5I\u0701\nI\3I\3I\7I\u0705\n"+ 15616 "I\fI\16I\u0708\13I\3I\5I\u070b\nI\5I\u070d\nI\3J\3J\3J\3J\3J\3J\7J\u0715"+ 15617 "\nJ\fJ\16J\u0718\13J\3J\3J\7J\u071c\nJ\fJ\16J\u071f\13J\3J\3J\7J\u0723"+ 15618 "\nJ\fJ\16J\u0726\13J\3J\3J\7J\u072a\nJ\fJ\16J\u072d\13J\3J\3J\5J\u0731"+ 15619 "\nJ\3J\3J\7J\u0735\nJ\fJ\16J\u0738\13J\3J\3J\5J\u073c\nJ\3J\3J\3J\3J\3"+ 15620 "J\7J\u0743\nJ\fJ\16J\u0746\13J\3J\3J\7J\u074a\nJ\fJ\16J\u074d\13J\3J\5"+ 15621 "J\u0750\nJ\3J\3J\6J\u0754\nJ\rJ\16J\u0755\3J\5J\u0759\nJ\5J\u075b\nJ\3"+ 15622 "J\3J\3K\3K\3K\3K\7K\u0763\nK\fK\16K\u0766\13K\3K\3K\3L\6L\u076b\nL\rL"+ 15623 "\16L\u076c\3L\2\2M\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60"+ 15624 "\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086"+ 15625 "\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\2\13\5\2\3\3\6\6\b\b"+ 15626 "\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"+ 15627 "\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"+ 15628 "\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"+ 15629 "\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"+ 15630 "\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"+ 15631 "\2\2\"\u0210\3\2\2\2$\u021b\3\2\2\2&\u0248\3\2\2\2(\u0255\3\2\2\2*\u0260"+ 15632 "\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"+ 15633 "\2\64\u02df\3\2\2\2\66\u02ea\3\2\2\28\u0317\3\2\2\2:\u0324\3\2\2\2<\u032f"+ 15634 "\3\2\2\2>\u035c\3\2\2\2@\u0369\3\2\2\2B\u0374\3\2\2\2D\u03a1\3\2\2\2F"+ 15635 "\u03ae\3\2\2\2H\u03b9\3\2\2\2J\u03e6\3\2\2\2L\u03f3\3\2\2\2N\u03fe\3\2"+ 15636 "\2\2P\u042b\3\2\2\2R\u0438\3\2\2\2T\u0443\3\2\2\2V\u0470\3\2\2\2X\u047d"+ 15637 "\3\2\2\2Z\u0488\3\2\2\2\\\u04b5\3\2\2\2^\u04c2\3\2\2\2`\u04cd\3\2\2\2"+ 15638 "b\u04fa\3\2\2\2d\u0507\3\2\2\2f\u0512\3\2\2\2h\u054e\3\2\2\2j\u0550\3"+ 15639 "\2\2\2l\u055d\3\2\2\2n\u056a\3\2\2\2p\u0577\3\2\2\2r\u0584\3\2\2\2t\u0591"+ 15640 "\3\2\2\2v\u059e\3\2\2\2x\u05ab\3\2\2\2z\u05b8\3\2\2\2|\u05c5\3\2\2\2~"+ 15641 "\u05d2\3\2\2\2\u0080\u05df\3\2\2\2\u0082\u05ec\3\2\2\2\u0084\u05f9\3\2"+ 15642 "\2\2\u0086\u0606\3\2\2\2\u0088\u060c\3\2\2\2\u008a\u0616\3\2\2\2\u008c"+ 15643 "\u063f\3\2\2\2\u008e\u0641\3\2\2\2\u0090\u070c\3\2\2\2\u0092\u070e\3\2"+ 15644 "\2\2\u0094\u075e\3\2\2\2\u0096\u076a\3\2\2\2\u0098\u00a1\5\4\3\2\u0099"+ 15645 "\u009a\6\2\2\2\u009a\u00a1\7\3\2\2\u009b\u00a1\5\u0094K\2\u009c\u00a1"+ 15646 "\7\5\2\2\u009d\u00a1\7\b\2\2\u009e\u00a1\5\u0096L\2\u009f\u00a1\5\u0092"+ 15647 "J\2\u00a0\u0098\3\2\2\2\u00a0\u0099\3\2\2\2\u00a0\u009b\3\2\2\2\u00a0"+ 15648 "\u009c\3\2\2\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u009f\3\2"+ 15649 "\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3"+ 15650 "\u00b1\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a7\7\3\2\2\u00a6\u00a5\3\2"+ 15651 "\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00ab\3\2\2\2\u00a8\u00aa\7\6\2\2\u00a9"+ 15652 "\u00a8\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2"+ 15653 "\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00b0\5\u0090I\2\u00af"+ 15654 "\u00a6\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2"+ 15655 "\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5\7\2\2\3\u00b5"+ 15656 "\3\3\2\2\2\u00b6\u00e6\5\f\7\2\u00b7\u00e6\5h\65\2\u00b8\u00e6\5\22\n"+ 15657 "\2\u00b9\u00e6\5\30\r\2\u00ba\u00e6\5\36\20\2\u00bb\u00e6\5$\23\2\u00bc"+ 15658 "\u00e6\5*\26\2\u00bd\u00e6\5\60\31\2\u00be\u00e6\5\66\34\2\u00bf\u00e6"+ 15659 "\5<\37\2\u00c0\u00e6\5B\"\2\u00c1\u00e6\5H%\2\u00c2\u00e6\5N(\2\u00c3"+ 15660 "\u00e6\5T+\2\u00c4\u00e6\5Z.\2\u00c5\u00e6\5f\64\2\u00c6\u00e6\5`\61\2"+ 15661 "\u00c7\u00e6\5\16\b\2\u00c8\u00e6\5\24\13\2\u00c9\u00e6\5\32\16\2\u00ca"+ 15662 "\u00e6\5 \21\2\u00cb\u00e6\5&\24\2\u00cc\u00e6\5,\27\2\u00cd\u00e6\5\62"+ 15663 "\32\2\u00ce\u00e6\58\35\2\u00cf\u00e6\5> \2\u00d0\u00e6\5D#\2\u00d1\u00e6"+ 15664 "\5J&\2\u00d2\u00e6\5P)\2\u00d3\u00e6\5V,\2\u00d4\u00e6\5b\62\2\u00d5\u00e6"+ 15665 "\5\\/\2\u00d6\u00e6\5\20\t\2\u00d7\u00e6\5\26\f\2\u00d8\u00e6\5\34\17"+ 15666 "\2\u00d9\u00e6\5\"\22\2\u00da\u00e6\5(\25\2\u00db\u00e6\5.\30\2\u00dc"+ 15667 "\u00e6\5\64\33\2\u00dd\u00e6\5:\36\2\u00de\u00e6\5@!\2\u00df\u00e6\5F"+ 15668 "$\2\u00e0\u00e6\5L\'\2\u00e1\u00e6\5R*\2\u00e2\u00e6\5X-\2\u00e3\u00e6"+ 15669 "\5d\63\2\u00e4\u00e6\5^\60\2\u00e5\u00b6\3\2\2\2\u00e5\u00b7\3\2\2\2\u00e5"+ 15670 "\u00b8\3\2\2\2\u00e5\u00b9\3\2\2\2\u00e5\u00ba\3\2\2\2\u00e5\u00bb\3\2"+ 15671 "\2\2\u00e5\u00bc\3\2\2\2\u00e5\u00bd\3\2\2\2\u00e5\u00be\3\2\2\2\u00e5"+ 15672 "\u00bf\3\2\2\2\u00e5\u00c0\3\2\2\2\u00e5\u00c1\3\2\2\2\u00e5\u00c2\3\2"+ 15673 "\2\2\u00e5\u00c3\3\2\2\2\u00e5\u00c4\3\2\2\2\u00e5\u00c5\3\2\2\2\u00e5"+ 15674 "\u00c6\3\2\2\2\u00e5\u00c7\3\2\2\2\u00e5\u00c8\3\2\2\2\u00e5\u00c9\3\2"+ 15675 "\2\2\u00e5\u00ca\3\2\2\2\u00e5\u00cb\3\2\2\2\u00e5\u00cc\3\2\2\2\u00e5"+ 15676 "\u00cd\3\2\2\2\u00e5\u00ce\3\2\2\2\u00e5\u00cf\3\2\2\2\u00e5\u00d0\3\2"+ 15677 "\2\2\u00e5\u00d1\3\2\2\2\u00e5\u00d2\3\2\2\2\u00e5\u00d3\3\2\2\2\u00e5"+ 15678 "\u00d4\3\2\2\2\u00e5\u00d5\3\2\2\2\u00e5\u00d6\3\2\2\2\u00e5\u00d7\3\2"+ 15679 "\2\2\u00e5\u00d8\3\2\2\2\u00e5\u00d9\3\2\2\2\u00e5\u00da\3\2\2\2\u00e5"+ 15680 "\u00db\3\2\2\2\u00e5\u00dc\3\2\2\2\u00e5\u00dd\3\2\2\2\u00e5\u00de\3\2"+ 15681 "\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2\u00e5\u00e1\3\2\2\2\u00e5"+ 15682 "\u00e2\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4\3\2\2\2\u00e6\5\3\2\2\2"+ 15683 "\u00e7\u00e8\7\7\2\2\u00e8\u00ef\7Y\2\2\u00e9\u00ee\5\n\6\2\u00ea\u00ee"+ 15684 "\7\b\2\2\u00eb\u00ee\7\3\2\2\u00ec\u00ee\7\6\2\2\u00ed\u00e9\3\2\2\2\u00ed"+ 15685 "\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec\3\2\2\2\u00ee\u00f1\3\2"+ 15686 "\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\3\2\2\2\u00f1"+ 15687 "\u00ef\3\2\2\2\u00f2\u00f3\79\2\2\u00f3\7\3\2\2\2\u00f4\u00f5\7\7\2\2"+ 15688 "\u00f5\u00f6\7;\2\2\u00f6\u00fa\7Y\2\2\u00f7\u00f9\t\2\2\2\u00f8\u00f7"+ 15689 "\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb"+ 15690 "\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\79\2\2\u00fe\t\3\2\2\2"+ 15691 "\u00ff\u0103\7Y\2\2\u0100\u0102\t\2\2\2\u0101\u0100\3\2\2\2\u0102\u0105"+ 15692 "\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105"+ 15693 "\u0103\3\2\2\2\u0106\u010a\7<\2\2\u0107\u0109\t\2\2\2\u0108\u0107\3\2"+ 15694 "\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b"+ 15695 "\u0110\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0111\7[\2\2\u010e\u0111\5\u0096"+ 15696 "L\2\u010f\u0111\7Y\2\2\u0110\u010d\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u010f"+ 15697 "\3\2\2\2\u0111\13\3\2\2\2\u0112\u011d\5\6\4\2\u0113\u011c\5\4\3\2\u0114"+ 15698 "\u0115\6\7\3\2\u0115\u011c\7\3\2\2\u0116\u011c\5\u0094K\2\u0117\u011c"+ 15699 "\7\5\2\2\u0118\u011c\7\b\2\2\u0119\u011c\5\u0096L\2\u011a\u011c\5\u0092"+ 15700 "J\2\u011b\u0113\3\2\2\2\u011b\u0114\3\2\2\2\u011b\u0116\3\2\2\2\u011b"+ 15701 "\u0117\3\2\2\2\u011b\u0118\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2"+ 15702 "\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+ 15703 "\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\5\b\5\2\u0121\u0133\3\2"+ 15704 "\2\2\u0122\u012d\5\6\4\2\u0123\u012c\5\4\3\2\u0124\u0125\6\7\4\2\u0125"+ 15705 "\u012c\7\3\2\2\u0126\u012c\5\u0094K\2\u0127\u012c\7\5\2\2\u0128\u012c"+ 15706 "\7\b\2\2\u0129\u012c\5\u0096L\2\u012a\u012c\5\u0092J\2\u012b\u0123\3\2"+ 15707 "\2\2\u012b\u0124\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012b"+ 15708 "\u0128\3\2\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f\3\2"+ 15709 "\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0130\3\2\2\2\u012f"+ 15710 "\u012d\3\2\2\2\u0130\u0131\b\7\1\2\u0131\u0133\3\2\2\2\u0132\u0112\3\2"+ 15711 "\2\2\u0132\u0122\3\2\2\2\u0133\r\3\2\2\2\u0134\u0135\7\7\2\2\u0135\u013c"+ 15712 "\7=\2\2\u0136\u013b\5\n\6\2\u0137\u013b\7\b\2\2\u0138\u013b\7\3\2\2\u0139"+ 15713 "\u013b\7\6\2\2\u013a\u0136\3\2\2\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2"+ 15714 "\2\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+ 15715 "\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0140\79"+ 15716 "\2\2\u0140\17\3\2\2\2\u0141\u0142\7\7\2\2\u0142\u0143\7;\2\2\u0143\u0147"+ 15717 "\7=\2\2\u0144\u0146\t\2\2\2\u0145\u0144\3\2\2\2\u0146\u0149\3\2\2\2\u0147"+ 15718 "\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2\u0149\u0147\3\2"+ 15719 "\2\2\u014a\u014b\79\2\2\u014b\21\3\2\2\2\u014c\u0174\5\16\b\2\u014d\u0173"+ 15720 "\5\f\7\2\u014e\u0173\5j\66\2\u014f\u0173\5\30\r\2\u0150\u0173\5\36\20"+ 15721 "\2\u0151\u0173\5$\23\2\u0152\u0173\5*\26\2\u0153\u0173\5\60\31\2\u0154"+ 15722 "\u0173\5\66\34\2\u0155\u0173\5<\37\2\u0156\u0173\5B\"\2\u0157\u0173\5"+ 15723 "H%\2\u0158\u0173\5N(\2\u0159\u0173\5T+\2\u015a\u0173\5Z.\2\u015b\u0173"+ 15724 "\5f\64\2\u015c\u0173\5`\61\2\u015d\u0173\5\24\13\2\u015e\u0173\5\32\16"+ 15725 "\2\u015f\u0173\5 \21\2\u0160\u0173\5&\24\2\u0161\u0173\5,\27\2\u0162\u0173"+ 15726 "\5\62\32\2\u0163\u0173\58\35\2\u0164\u0173\5> \2\u0165\u0173\5D#\2\u0166"+ 15727 "\u0173\5J&\2\u0167\u0173\5P)\2\u0168\u0173\5V,\2\u0169\u0173\5b\62\2\u016a"+ 15728 "\u0173\5\\/\2\u016b\u016c\6\n\5\2\u016c\u0173\7\3\2\2\u016d\u0173\5\u0094"+ 15729 "K\2\u016e\u0173\7\5\2\2\u016f\u0173\7\b\2\2\u0170\u0173\5\u0096L\2\u0171"+ 15730 "\u0173\5\u0092J\2\u0172\u014d\3\2\2\2\u0172\u014e\3\2\2\2\u0172\u014f"+ 15731 "\3\2\2\2\u0172\u0150\3\2\2\2\u0172\u0151\3\2\2\2\u0172\u0152\3\2\2\2\u0172"+ 15732 "\u0153\3\2\2\2\u0172\u0154\3\2\2\2\u0172\u0155\3\2\2\2\u0172\u0156\3\2"+ 15733 "\2\2\u0172\u0157\3\2\2\2\u0172\u0158\3\2\2\2\u0172\u0159\3\2\2\2\u0172"+ 15734 "\u015a\3\2\2\2\u0172\u015b\3\2\2\2\u0172\u015c\3\2\2\2\u0172\u015d\3\2"+ 15735 "\2\2\u0172\u015e\3\2\2\2\u0172\u015f\3\2\2\2\u0172\u0160\3\2\2\2\u0172"+ 15736 "\u0161\3\2\2\2\u0172\u0162\3\2\2\2\u0172\u0163\3\2\2\2\u0172\u0164\3\2"+ 15737 "\2\2\u0172\u0165\3\2\2\2\u0172\u0166\3\2\2\2\u0172\u0167\3\2\2\2\u0172"+ 15738 "\u0168\3\2\2\2\u0172\u0169\3\2\2\2\u0172\u016a\3\2\2\2\u0172\u016b\3\2"+ 15739 "\2\2\u0172\u016d\3\2\2\2\u0172\u016e\3\2\2\2\u0172\u016f\3\2\2\2\u0172"+ 15740 "\u0170\3\2\2\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2"+ 15741 "\2\2\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177"+ 15742 "\u0178\5\20\t\2\u0178\23\3\2\2\2\u0179\u017a\7\7\2\2\u017a\u0181\7>\2"+ 15743 "\2\u017b\u0180\5\n\6\2\u017c\u0180\7\b\2\2\u017d\u0180\7\3\2\2\u017e\u0180"+ 15744 "\7\6\2\2\u017f\u017b\3\2\2\2\u017f\u017c\3\2\2\2\u017f\u017d\3\2\2\2\u017f"+ 15745 "\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+ 15746 "\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\79\2\2\u0185"+ 15747 "\25\3\2\2\2\u0186\u0187\7\7\2\2\u0187\u0188\7;\2\2\u0188\u018c\7>\2\2"+ 15748 "\u0189\u018b\t\2\2\2\u018a\u0189\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a"+ 15749 "\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f"+ 15750 "\u0190\79\2\2\u0190\27\3\2\2\2\u0191\u01b9\5\24\13\2\u0192\u01b8\5\f\7"+ 15751 "\2\u0193\u01b8\5j\66\2\u0194\u01b8\5\22\n\2\u0195\u01b8\5\36\20\2\u0196"+ 15752 "\u01b8\5$\23\2\u0197\u01b8\5*\26\2\u0198\u01b8\5\60\31\2\u0199\u01b8\5"+ 15753 "\66\34\2\u019a\u01b8\5<\37\2\u019b\u01b8\5B\"\2\u019c\u01b8\5H%\2\u019d"+ 15754 "\u01b8\5N(\2\u019e\u01b8\5T+\2\u019f\u01b8\5Z.\2\u01a0\u01b8\5f\64\2\u01a1"+ 15755 "\u01b8\5`\61\2\u01a2\u01b8\5\16\b\2\u01a3\u01b8\5\32\16\2\u01a4\u01b8"+ 15756 "\5 \21\2\u01a5\u01b8\5&\24\2\u01a6\u01b8\5,\27\2\u01a7\u01b8\5\62\32\2"+ 15757 "\u01a8\u01b8\58\35\2\u01a9\u01b8\5> \2\u01aa\u01b8\5D#\2\u01ab\u01b8\5"+ 15758 "J&\2\u01ac\u01b8\5P)\2\u01ad\u01b8\5V,\2\u01ae\u01b8\5b\62\2\u01af\u01b8"+ 15759 "\5\\/\2\u01b0\u01b1\6\r\6\2\u01b1\u01b8\7\3\2\2\u01b2\u01b8\5\u0094K\2"+ 15760 "\u01b3\u01b8\7\5\2\2\u01b4\u01b8\7\b\2\2\u01b5\u01b8\5\u0096L\2\u01b6"+ 15761 "\u01b8\5\u0092J\2\u01b7\u0192\3\2\2\2\u01b7\u0193\3\2\2\2\u01b7\u0194"+ 15762 "\3\2\2\2\u01b7\u0195\3\2\2\2\u01b7\u0196\3\2\2\2\u01b7\u0197\3\2\2\2\u01b7"+ 15763 "\u0198\3\2\2\2\u01b7\u0199\3\2\2\2\u01b7\u019a\3\2\2\2\u01b7\u019b\3\2"+ 15764 "\2\2\u01b7\u019c\3\2\2\2\u01b7\u019d\3\2\2\2\u01b7\u019e\3\2\2\2\u01b7"+ 15765 "\u019f\3\2\2\2\u01b7\u01a0\3\2\2\2\u01b7\u01a1\3\2\2\2\u01b7\u01a2\3\2"+ 15766 "\2\2\u01b7\u01a3\3\2\2\2\u01b7\u01a4\3\2\2\2\u01b7\u01a5\3\2\2\2\u01b7"+ 15767 "\u01a6\3\2\2\2\u01b7\u01a7\3\2\2\2\u01b7\u01a8\3\2\2\2\u01b7\u01a9\3\2"+ 15768 "\2\2\u01b7\u01aa\3\2\2\2\u01b7\u01ab\3\2\2\2\u01b7\u01ac\3\2\2\2\u01b7"+ 15769 "\u01ad\3\2\2\2\u01b7\u01ae\3\2\2\2\u01b7\u01af\3\2\2\2\u01b7\u01b0\3\2"+ 15770 "\2\2\u01b7\u01b2\3\2\2\2\u01b7\u01b3\3\2\2\2\u01b7\u01b4\3\2\2\2\u01b7"+ 15771 "\u01b5\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2"+ 15772 "\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc"+ 15773 "\u01bd\5\26\f\2\u01bd\31\3\2\2\2\u01be\u01bf\7\7\2\2\u01bf\u01c6\7?\2"+ 15774 "\2\u01c0\u01c5\5\n\6\2\u01c1\u01c5\7\b\2\2\u01c2\u01c5\7\3\2\2\u01c3\u01c5"+ 15775 "\7\6\2\2\u01c4\u01c0\3\2\2\2\u01c4\u01c1\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c4"+ 15776 "\u01c3\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2"+ 15777 "\2\2\u01c7\u01c9\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\79\2\2\u01ca"+ 15778 "\33\3\2\2\2\u01cb\u01cc\7\7\2\2\u01cc\u01cd\7;\2\2\u01cd\u01d1\7?\2\2"+ 15779 "\u01ce\u01d0\t\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+ 15780 "\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d4\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+ 15781 "\u01d5\79\2\2\u01d5\35\3\2\2\2\u01d6\u01fe\5\32\16\2\u01d7\u01fd\5\f\7"+ 15782 "\2\u01d8\u01fd\5j\66\2\u01d9\u01fd\5\22\n\2\u01da\u01fd\5\30\r\2\u01db"+ 15783 "\u01fd\5$\23\2\u01dc\u01fd\5*\26\2\u01dd\u01fd\5\60\31\2\u01de\u01fd\5"+ 15784 "\66\34\2\u01df\u01fd\5<\37\2\u01e0\u01fd\5B\"\2\u01e1\u01fd\5H%\2\u01e2"+ 15785 "\u01fd\5N(\2\u01e3\u01fd\5T+\2\u01e4\u01fd\5Z.\2\u01e5\u01fd\5f\64\2\u01e6"+ 15786 "\u01fd\5`\61\2\u01e7\u01fd\5\16\b\2\u01e8\u01fd\5\24\13\2\u01e9\u01fd"+ 15787 "\5 \21\2\u01ea\u01fd\5&\24\2\u01eb\u01fd\5,\27\2\u01ec\u01fd\5\62\32\2"+ 15788 "\u01ed\u01fd\58\35\2\u01ee\u01fd\5> \2\u01ef\u01fd\5D#\2\u01f0\u01fd\5"+ 15789 "J&\2\u01f1\u01fd\5P)\2\u01f2\u01fd\5V,\2\u01f3\u01fd\5b\62\2\u01f4\u01fd"+ 15790 "\5\\/\2\u01f5\u01f6\6\20\7\2\u01f6\u01fd\7\3\2\2\u01f7\u01fd\5\u0094K"+ 15791 "\2\u01f8\u01fd\7\5\2\2\u01f9\u01fd\7\b\2\2\u01fa\u01fd\5\u0096L\2\u01fb"+ 15792 "\u01fd\5\u0092J\2\u01fc\u01d7\3\2\2\2\u01fc\u01d8\3\2\2\2\u01fc\u01d9"+ 15793 "\3\2\2\2\u01fc\u01da\3\2\2\2\u01fc\u01db\3\2\2\2\u01fc\u01dc\3\2\2\2\u01fc"+ 15794 "\u01dd\3\2\2\2\u01fc\u01de\3\2\2\2\u01fc\u01df\3\2\2\2\u01fc\u01e0\3\2"+ 15795 "\2\2\u01fc\u01e1\3\2\2\2\u01fc\u01e2\3\2\2\2\u01fc\u01e3\3\2\2\2\u01fc"+ 15796 "\u01e4\3\2\2\2\u01fc\u01e5\3\2\2\2\u01fc\u01e6\3\2\2\2\u01fc\u01e7\3\2"+ 15797 "\2\2\u01fc\u01e8\3\2\2\2\u01fc\u01e9\3\2\2\2\u01fc\u01ea\3\2\2\2\u01fc"+ 15798 "\u01eb\3\2\2\2\u01fc\u01ec\3\2\2\2\u01fc\u01ed\3\2\2\2\u01fc\u01ee\3\2"+ 15799 "\2\2\u01fc\u01ef\3\2\2\2\u01fc\u01f0\3\2\2\2\u01fc\u01f1\3\2\2\2\u01fc"+ 15800 "\u01f2\3\2\2\2\u01fc\u01f3\3\2\2\2\u01fc\u01f4\3\2\2\2\u01fc\u01f5\3\2"+ 15801 "\2\2\u01fc\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc"+ 15802 "\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2"+ 15803 "\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201\3\2\2\2\u0200\u01fe\3\2\2\2\u0201"+ 15804 "\u0202\5\34\17\2\u0202\37\3\2\2\2\u0203\u0204\7\7\2\2\u0204\u020b\7@\2"+ 15805 "\2\u0205\u020a\5\n\6\2\u0206\u020a\7\b\2\2\u0207\u020a\7\3\2\2\u0208\u020a"+ 15806 "\7\6\2\2\u0209\u0205\3\2\2\2\u0209\u0206\3\2\2\2\u0209\u0207\3\2\2\2\u0209"+ 15807 "\u0208\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2"+ 15808 "\2\2\u020c\u020e\3\2\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f"+ 15809 "!\3\2\2\2\u0210\u0211\7\7\2\2\u0211\u0212\7;\2\2\u0212\u0216\7@\2\2\u0213"+ 15810 "\u0215\t\2\2\2\u0214\u0213\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2"+ 15811 "\2\2\u0216\u0217\3\2\2\2\u0217\u0219\3\2\2\2\u0218\u0216\3\2\2\2\u0219"+ 15812 "\u021a\79\2\2\u021a#\3\2\2\2\u021b\u0243\5 \21\2\u021c\u0242\5\f\7\2\u021d"+ 15813 "\u0242\5j\66\2\u021e\u0242\5\22\n\2\u021f\u0242\5\30\r\2\u0220\u0242\5"+ 15814 "\36\20\2\u0221\u0242\5*\26\2\u0222\u0242\5\60\31\2\u0223\u0242\5\66\34"+ 15815 "\2\u0224\u0242\5<\37\2\u0225\u0242\5B\"\2\u0226\u0242\5H%\2\u0227\u0242"+ 15816 "\5N(\2\u0228\u0242\5T+\2\u0229\u0242\5Z.\2\u022a\u0242\5f\64\2\u022b\u0242"+ 15817 "\5`\61\2\u022c\u0242\5\16\b\2\u022d\u0242\5\24\13\2\u022e\u0242\5 \21"+ 15818 "\2\u022f\u0242\5&\24\2\u0230\u0242\5,\27\2\u0231\u0242\5\62\32\2\u0232"+ 15819 "\u0242\58\35\2\u0233\u0242\5> \2\u0234\u0242\5D#\2\u0235\u0242\5J&\2\u0236"+ 15820 "\u0242\5P)\2\u0237\u0242\5V,\2\u0238\u0242\5b\62\2\u0239\u0242\5\\/\2"+ 15821 "\u023a\u023b\6\23\b\2\u023b\u0242\7\3\2\2\u023c\u0242\5\u0094K\2\u023d"+ 15822 "\u0242\7\5\2\2\u023e\u0242\7\b\2\2\u023f\u0242\5\u0096L\2\u0240\u0242"+ 15823 "\5\u0092J\2\u0241\u021c\3\2\2\2\u0241\u021d\3\2\2\2\u0241\u021e\3\2\2"+ 15824 "\2\u0241\u021f\3\2\2\2\u0241\u0220\3\2\2\2\u0241\u0221\3\2\2\2\u0241\u0222"+ 15825 "\3\2\2\2\u0241\u0223\3\2\2\2\u0241\u0224\3\2\2\2\u0241\u0225\3\2\2\2\u0241"+ 15826 "\u0226\3\2\2\2\u0241\u0227\3\2\2\2\u0241\u0228\3\2\2\2\u0241\u0229\3\2"+ 15827 "\2\2\u0241\u022a\3\2\2\2\u0241\u022b\3\2\2\2\u0241\u022c\3\2\2\2\u0241"+ 15828 "\u022d\3\2\2\2\u0241\u022e\3\2\2\2\u0241\u022f\3\2\2\2\u0241\u0230\3\2"+ 15829 "\2\2\u0241\u0231\3\2\2\2\u0241\u0232\3\2\2\2\u0241\u0233\3\2\2\2\u0241"+ 15830 "\u0234\3\2\2\2\u0241\u0235\3\2\2\2\u0241\u0236\3\2\2\2\u0241\u0237\3\2"+ 15831 "\2\2\u0241\u0238\3\2\2\2\u0241\u0239\3\2\2\2\u0241\u023a\3\2\2\2\u0241"+ 15832 "\u023c\3\2\2\2\u0241\u023d\3\2\2\2\u0241\u023e\3\2\2\2\u0241\u023f\3\2"+ 15833 "\2\2\u0241\u0240\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243"+ 15834 "\u0244\3\2\2\2\u0244\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\5\""+ 15835 "\22\2\u0247%\3\2\2\2\u0248\u0249\7\7\2\2\u0249\u0250\7A\2\2\u024a\u024f"+ 15836 "\5\n\6\2\u024b\u024f\7\b\2\2\u024c\u024f\7\3\2\2\u024d\u024f\7\6\2\2\u024e"+ 15837 "\u024a\3\2\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2"+ 15838 "\2\2\u024f\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251"+ 15839 "\u0253\3\2\2\2\u0252\u0250\3\2\2\2\u0253\u0254\79\2\2\u0254\'\3\2\2\2"+ 15840 "\u0255\u0256\7\7\2\2\u0256\u0257\7;\2\2\u0257\u025b\7A\2\2\u0258\u025a"+ 15841 "\t\2\2\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b"+ 15842 "\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f\79"+ 15843 "\2\2\u025f)\3\2\2\2\u0260\u0288\5&\24\2\u0261\u0287\5\f\7\2\u0262\u0287"+ 15844 "\5j\66\2\u0263\u0287\5\22\n\2\u0264\u0287\5\30\r\2\u0265\u0287\5\36\20"+ 15845 "\2\u0266\u0287\5$\23\2\u0267\u0287\5\60\31\2\u0268\u0287\5\66\34\2\u0269"+ 15846 "\u0287\5<\37\2\u026a\u0287\5B\"\2\u026b\u0287\5H%\2\u026c\u0287\5N(\2"+ 15847 "\u026d\u0287\5T+\2\u026e\u0287\5Z.\2\u026f\u0287\5f\64\2\u0270\u0287\5"+ 15848 "`\61\2\u0271\u0287\5\16\b\2\u0272\u0287\5\24\13\2\u0273\u0287\5\32\16"+ 15849 "\2\u0274\u0287\5 \21\2\u0275\u0287\5,\27\2\u0276\u0287\5\62\32\2\u0277"+ 15850 "\u0287\58\35\2\u0278\u0287\5> \2\u0279\u0287\5D#\2\u027a\u0287\5J&\2\u027b"+ 15851 "\u0287\5P)\2\u027c\u0287\5V,\2\u027d\u0287\5b\62\2\u027e\u0287\5\\/\2"+ 15852 "\u027f\u0280\6\26\t\2\u0280\u0287\7\3\2\2\u0281\u0287\5\u0094K\2\u0282"+ 15853 "\u0287\7\5\2\2\u0283\u0287\7\b\2\2\u0284\u0287\5\u0096L\2\u0285\u0287"+ 15854 "\5\u0092J\2\u0286\u0261\3\2\2\2\u0286\u0262\3\2\2\2\u0286\u0263\3\2\2"+ 15855 "\2\u0286\u0264\3\2\2\2\u0286\u0265\3\2\2\2\u0286\u0266\3\2\2\2\u0286\u0267"+ 15856 "\3\2\2\2\u0286\u0268\3\2\2\2\u0286\u0269\3\2\2\2\u0286\u026a\3\2\2\2\u0286"+ 15857 "\u026b\3\2\2\2\u0286\u026c\3\2\2\2\u0286\u026d\3\2\2\2\u0286\u026e\3\2"+ 15858 "\2\2\u0286\u026f\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0271\3\2\2\2\u0286"+ 15859 "\u0272\3\2\2\2\u0286\u0273\3\2\2\2\u0286\u0274\3\2\2\2\u0286\u0275\3\2"+ 15860 "\2\2\u0286\u0276\3\2\2\2\u0286\u0277\3\2\2\2\u0286\u0278\3\2\2\2\u0286"+ 15861 "\u0279\3\2\2\2\u0286\u027a\3\2\2\2\u0286\u027b\3\2\2\2\u0286\u027c\3\2"+ 15862 "\2\2\u0286\u027d\3\2\2\2\u0286\u027e\3\2\2\2\u0286\u027f\3\2\2\2\u0286"+ 15863 "\u0281\3\2\2\2\u0286\u0282\3\2\2\2\u0286\u0283\3\2\2\2\u0286\u0284\3\2"+ 15864 "\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+ 15865 "\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\5("+ 15866 "\25\2\u028c+\3\2\2\2\u028d\u028e\7\7\2\2\u028e\u0295\7B\2\2\u028f\u0294"+ 15867 "\5\n\6\2\u0290\u0294\7\b\2\2\u0291\u0294\7\3\2\2\u0292\u0294\7\6\2\2\u0293"+ 15868 "\u028f\3\2\2\2\u0293\u0290\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0292\3\2"+ 15869 "\2\2\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296"+ 15870 "\u0298\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0299\79\2\2\u0299-\3\2\2\2\u029a"+ 15871 "\u029b\7\7\2\2\u029b\u029c\7;\2\2\u029c\u02a0\7B\2\2\u029d\u029f\t\2\2"+ 15872 "\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e\3\2\2\2\u02a0\u02a1"+ 15873 "\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a3\u02a4\79\2\2\u02a4"+ 15874 "/\3\2\2\2\u02a5\u02cd\5,\27\2\u02a6\u02cc\5\f\7\2\u02a7\u02cc\5j\66\2"+ 15875 "\u02a8\u02cc\5\22\n\2\u02a9\u02cc\5\30\r\2\u02aa\u02cc\5\36\20\2\u02ab"+ 15876 "\u02cc\5$\23\2\u02ac\u02cc\5*\26\2\u02ad\u02cc\5\66\34\2\u02ae\u02cc\5"+ 15877 "<\37\2\u02af\u02cc\5B\"\2\u02b0\u02cc\5H%\2\u02b1\u02cc\5N(\2\u02b2\u02cc"+ 15878 "\5T+\2\u02b3\u02cc\5Z.\2\u02b4\u02cc\5f\64\2\u02b5\u02cc\5`\61\2\u02b6"+ 15879 "\u02cc\5\16\b\2\u02b7\u02cc\5\24\13\2\u02b8\u02cc\5\32\16\2\u02b9\u02cc"+ 15880 "\5 \21\2\u02ba\u02cc\5&\24\2\u02bb\u02cc\5\62\32\2\u02bc\u02cc\58\35\2"+ 15881 "\u02bd\u02cc\5> \2\u02be\u02cc\5D#\2\u02bf\u02cc\5J&\2\u02c0\u02cc\5P"+ 15882 ")\2\u02c1\u02cc\5V,\2\u02c2\u02cc\5b\62\2\u02c3\u02cc\5\\/\2\u02c4\u02c5"+ 15883 "\6\31\n\2\u02c5\u02cc\7\3\2\2\u02c6\u02cc\5\u0094K\2\u02c7\u02cc\7\5\2"+ 15884 "\2\u02c8\u02cc\7\b\2\2\u02c9\u02cc\5\u0096L\2\u02ca\u02cc\5\u0092J\2\u02cb"+ 15885 "\u02a6\3\2\2\2\u02cb\u02a7\3\2\2\2\u02cb\u02a8\3\2\2\2\u02cb\u02a9\3\2"+ 15886 "\2\2\u02cb\u02aa\3\2\2\2\u02cb\u02ab\3\2\2\2\u02cb\u02ac\3\2\2\2\u02cb"+ 15887 "\u02ad\3\2\2\2\u02cb\u02ae\3\2\2\2\u02cb\u02af\3\2\2\2\u02cb\u02b0\3\2"+ 15888 "\2\2\u02cb\u02b1\3\2\2\2\u02cb\u02b2\3\2\2\2\u02cb\u02b3\3\2\2\2\u02cb"+ 15889 "\u02b4\3\2\2\2\u02cb\u02b5\3\2\2\2\u02cb\u02b6\3\2\2\2\u02cb\u02b7\3\2"+ 15890 "\2\2\u02cb\u02b8\3\2\2\2\u02cb\u02b9\3\2\2\2\u02cb\u02ba\3\2\2\2\u02cb"+ 15891 "\u02bb\3\2\2\2\u02cb\u02bc\3\2\2\2\u02cb\u02bd\3\2\2\2\u02cb\u02be\3\2"+ 15892 "\2\2\u02cb\u02bf\3\2\2\2\u02cb\u02c0\3\2\2\2\u02cb\u02c1\3\2\2\2\u02cb"+ 15893 "\u02c2\3\2\2\2\u02cb\u02c3\3\2\2\2\u02cb\u02c4\3\2\2\2\u02cb\u02c6\3\2"+ 15894 "\2\2\u02cb\u02c7\3\2\2\2\u02cb\u02c8\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cb"+ 15895 "\u02ca\3\2\2\2\u02cc\u02cf\3\2\2\2\u02cd\u02cb\3\2\2\2\u02cd\u02ce\3\2"+ 15896 "\2\2\u02ce\u02d0\3\2\2\2\u02cf\u02cd\3\2\2\2\u02d0\u02d1\5.\30\2\u02d1"+ 15897 "\61\3\2\2\2\u02d2\u02d3\7\7\2\2\u02d3\u02da\7C\2\2\u02d4\u02d9\5\n\6\2"+ 15898 "\u02d5\u02d9\7\b\2\2\u02d6\u02d9\7\3\2\2\u02d7\u02d9\7\6\2\2\u02d8\u02d4"+ 15899 "\3\2\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d8\u02d7\3\2\2\2\u02d9"+ 15900 "\u02dc\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2"+ 15901 "\2\2\u02dc\u02da\3\2\2\2\u02dd\u02de\79\2\2\u02de\63\3\2\2\2\u02df\u02e0"+ 15902 "\7\7\2\2\u02e0\u02e1\7;\2\2\u02e1\u02e5\7C\2\2\u02e2\u02e4\t\2\2\2\u02e3"+ 15903 "\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2"+ 15904 "\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\79\2\2\u02e9"+ 15905 "\65\3\2\2\2\u02ea\u0312\5\62\32\2\u02eb\u0311\5\f\7\2\u02ec\u0311\5j\66"+ 15906 "\2\u02ed\u0311\5\22\n\2\u02ee\u0311\5\30\r\2\u02ef\u0311\5\36\20\2\u02f0"+ 15907 "\u0311\5$\23\2\u02f1\u0311\5*\26\2\u02f2\u0311\5\60\31\2\u02f3\u0311\5"+ 15908 "<\37\2\u02f4\u0311\5B\"\2\u02f5\u0311\5H%\2\u02f6\u0311\5N(\2\u02f7\u0311"+ 15909 "\5T+\2\u02f8\u0311\5Z.\2\u02f9\u0311\5f\64\2\u02fa\u0311\5`\61\2\u02fb"+ 15910 "\u0311\5\16\b\2\u02fc\u0311\5\24\13\2\u02fd\u0311\5\32\16\2\u02fe\u0311"+ 15911 "\5 \21\2\u02ff\u0311\5&\24\2\u0300\u0311\5,\27\2\u0301\u0311\58\35\2\u0302"+ 15912 "\u0311\5> \2\u0303\u0311\5D#\2\u0304\u0311\5J&\2\u0305\u0311\5P)\2\u0306"+ 15913 "\u0311\5V,\2\u0307\u0311\5b\62\2\u0308\u0311\5\\/\2\u0309\u030a\6\34\13"+ 15914 "\2\u030a\u0311\7\3\2\2\u030b\u0311\5\u0094K\2\u030c\u0311\7\5\2\2\u030d"+ 15915 "\u0311\7\b\2\2\u030e\u0311\5\u0096L\2\u030f\u0311\5\u0092J\2\u0310\u02eb"+ 15916 "\3\2\2\2\u0310\u02ec\3\2\2\2\u0310\u02ed\3\2\2\2\u0310\u02ee\3\2\2\2\u0310"+ 15917 "\u02ef\3\2\2\2\u0310\u02f0\3\2\2\2\u0310\u02f1\3\2\2\2\u0310\u02f2\3\2"+ 15918 "\2\2\u0310\u02f3\3\2\2\2\u0310\u02f4\3\2\2\2\u0310\u02f5\3\2\2\2\u0310"+ 15919 "\u02f6\3\2\2\2\u0310\u02f7\3\2\2\2\u0310\u02f8\3\2\2\2\u0310\u02f9\3\2"+ 15920 "\2\2\u0310\u02fa\3\2\2\2\u0310\u02fb\3\2\2\2\u0310\u02fc\3\2\2\2\u0310"+ 15921 "\u02fd\3\2\2\2\u0310\u02fe\3\2\2\2\u0310\u02ff\3\2\2\2\u0310\u0300\3\2"+ 15922 "\2\2\u0310\u0301\3\2\2\2\u0310\u0302\3\2\2\2\u0310\u0303\3\2\2\2\u0310"+ 15923 "\u0304\3\2\2\2\u0310\u0305\3\2\2\2\u0310\u0306\3\2\2\2\u0310\u0307\3\2"+ 15924 "\2\2\u0310\u0308\3\2\2\2\u0310\u0309\3\2\2\2\u0310\u030b\3\2\2\2\u0310"+ 15925 "\u030c\3\2\2\2\u0310\u030d\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u030f\3\2"+ 15926 "\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+ 15927 "\u0315\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0316\5\64\33\2\u0316\67\3\2"+ 15928 "\2\2\u0317\u0318\7\7\2\2\u0318\u031f\7D\2\2\u0319\u031e\5\n\6\2\u031a"+ 15929 "\u031e\7\b\2\2\u031b\u031e\7\3\2\2\u031c\u031e\7\6\2\2\u031d\u0319\3\2"+ 15930 "\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031c\3\2\2\2\u031e"+ 15931 "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2"+ 15932 "\2\2\u0321\u031f\3\2\2\2\u0322\u0323\79\2\2\u03239\3\2\2\2\u0324\u0325"+ 15933 "\7\7\2\2\u0325\u0326\7;\2\2\u0326\u032a\7D\2\2\u0327\u0329\t\2\2\2\u0328"+ 15934 "\u0327\3\2\2\2\u0329\u032c\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u032b\3\2"+ 15935 "\2\2\u032b\u032d\3\2\2\2\u032c\u032a\3\2\2\2\u032d\u032e\79\2\2\u032e"+ 15936 ";\3\2\2\2\u032f\u0357\58\35\2\u0330\u0356\5\f\7\2\u0331\u0356\5j\66\2"+ 15937 "\u0332\u0356\5\22\n\2\u0333\u0356\5\30\r\2\u0334\u0356\5\36\20\2\u0335"+ 15938 "\u0356\5$\23\2\u0336\u0356\5*\26\2\u0337\u0356\5\60\31\2\u0338\u0356\5"+ 15939 "\66\34\2\u0339\u0356\5B\"\2\u033a\u0356\5H%\2\u033b\u0356\5N(\2\u033c"+ 15940 "\u0356\5T+\2\u033d\u0356\5Z.\2\u033e\u0356\5f\64\2\u033f\u0356\5`\61\2"+ 15941 "\u0340\u0356\5\16\b\2\u0341\u0356\5\24\13\2\u0342\u0356\5\32\16\2\u0343"+ 15942 "\u0356\5 \21\2\u0344\u0356\5&\24\2\u0345\u0356\5,\27\2\u0346\u0356\5\62"+ 15943 "\32\2\u0347\u0356\5> \2\u0348\u0356\5D#\2\u0349\u0356\5J&\2\u034a\u0356"+ 15944 "\5P)\2\u034b\u0356\5V,\2\u034c\u0356\5b\62\2\u034d\u0356\5\\/\2\u034e"+ 15945 "\u034f\6\37\f\2\u034f\u0356\7\3\2\2\u0350\u0356\5\u0094K\2\u0351\u0356"+ 15946 "\7\5\2\2\u0352\u0356\7\b\2\2\u0353\u0356\5\u0096L\2\u0354\u0356\5\u0092"+ 15947 "J\2\u0355\u0330\3\2\2\2\u0355\u0331\3\2\2\2\u0355\u0332\3\2\2\2\u0355"+ 15948 "\u0333\3\2\2\2\u0355\u0334\3\2\2\2\u0355\u0335\3\2\2\2\u0355\u0336\3\2"+ 15949 "\2\2\u0355\u0337\3\2\2\2\u0355\u0338\3\2\2\2\u0355\u0339\3\2\2\2\u0355"+ 15950 "\u033a\3\2\2\2\u0355\u033b\3\2\2\2\u0355\u033c\3\2\2\2\u0355\u033d\3\2"+ 15951 "\2\2\u0355\u033e\3\2\2\2\u0355\u033f\3\2\2\2\u0355\u0340\3\2\2\2\u0355"+ 15952 "\u0341\3\2\2\2\u0355\u0342\3\2\2\2\u0355\u0343\3\2\2\2\u0355\u0344\3\2"+ 15953 "\2\2\u0355\u0345\3\2\2\2\u0355\u0346\3\2\2\2\u0355\u0347\3\2\2\2\u0355"+ 15954 "\u0348\3\2\2\2\u0355\u0349\3\2\2\2\u0355\u034a\3\2\2\2\u0355\u034b\3\2"+ 15955 "\2\2\u0355\u034c\3\2\2\2\u0355\u034d\3\2\2\2\u0355\u034e\3\2\2\2\u0355"+ 15956 "\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0355\u0352\3\2\2\2\u0355\u0353\3\2"+ 15957 "\2\2\u0355\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357"+ 15958 "\u0358\3\2\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\5:"+ 15959 "\36\2\u035b=\3\2\2\2\u035c\u035d\7\7\2\2\u035d\u0364\7E\2\2\u035e\u0363"+ 15960 "\5\n\6\2\u035f\u0363\7\b\2\2\u0360\u0363\7\3\2\2\u0361\u0363\7\6\2\2\u0362"+ 15961 "\u035e\3\2\2\2\u0362\u035f\3\2\2\2\u0362\u0360\3\2\2\2\u0362\u0361\3\2"+ 15962 "\2\2\u0363\u0366\3\2\2\2\u0364\u0362\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+ 15963 "\u0367\3\2\2\2\u0366\u0364\3\2\2\2\u0367\u0368\79\2\2\u0368?\3\2\2\2\u0369"+ 15964 "\u036a\7\7\2\2\u036a\u036b\7;\2\2\u036b\u036f\7E\2\2\u036c\u036e\t\2\2"+ 15965 "\2\u036d\u036c\3\2\2\2\u036e\u0371\3\2\2\2\u036f\u036d\3\2\2\2\u036f\u0370"+ 15966 "\3\2\2\2\u0370\u0372\3\2\2\2\u0371\u036f\3\2\2\2\u0372\u0373\79\2\2\u0373"+ 15967 "A\3\2\2\2\u0374\u039c\5> \2\u0375\u039b\5\f\7\2\u0376\u039b\5j\66\2\u0377"+ 15968 "\u039b\5\22\n\2\u0378\u039b\5\30\r\2\u0379\u039b\5\36\20\2\u037a\u039b"+ 15969 "\5$\23\2\u037b\u039b\5*\26\2\u037c\u039b\5\60\31\2\u037d\u039b\5\66\34"+ 15970 "\2\u037e\u039b\5<\37\2\u037f\u039b\5H%\2\u0380\u039b\5N(\2\u0381\u039b"+ 15971 "\5T+\2\u0382\u039b\5Z.\2\u0383\u039b\5f\64\2\u0384\u039b\5`\61\2\u0385"+ 15972 "\u039b\5\16\b\2\u0386\u039b\5\24\13\2\u0387\u039b\5\32\16\2\u0388\u039b"+ 15973 "\5 \21\2\u0389\u039b\5&\24\2\u038a\u039b\5,\27\2\u038b\u039b\5\62\32\2"+ 15974 "\u038c\u039b\58\35\2\u038d\u039b\5D#\2\u038e\u039b\5J&\2\u038f\u039b\5"+ 15975 "P)\2\u0390\u039b\5V,\2\u0391\u039b\5b\62\2\u0392\u039b\5\\/\2\u0393\u0394"+ 15976 "\6\"\r\2\u0394\u039b\7\3\2\2\u0395\u039b\5\u0094K\2\u0396\u039b\7\5\2"+ 15977 "\2\u0397\u039b\7\b\2\2\u0398\u039b\5\u0096L\2\u0399\u039b\5\u0092J\2\u039a"+ 15978 "\u0375\3\2\2\2\u039a\u0376\3\2\2\2\u039a\u0377\3\2\2\2\u039a\u0378\3\2"+ 15979 "\2\2\u039a\u0379\3\2\2\2\u039a\u037a\3\2\2\2\u039a\u037b\3\2\2\2\u039a"+ 15980 "\u037c\3\2\2\2\u039a\u037d\3\2\2\2\u039a\u037e\3\2\2\2\u039a\u037f\3\2"+ 15981 "\2\2\u039a\u0380\3\2\2\2\u039a\u0381\3\2\2\2\u039a\u0382\3\2\2\2\u039a"+ 15982 "\u0383\3\2\2\2\u039a\u0384\3\2\2\2\u039a\u0385\3\2\2\2\u039a\u0386\3\2"+ 15983 "\2\2\u039a\u0387\3\2\2\2\u039a\u0388\3\2\2\2\u039a\u0389\3\2\2\2\u039a"+ 15984 "\u038a\3\2\2\2\u039a\u038b\3\2\2\2\u039a\u038c\3\2\2\2\u039a\u038d\3\2"+ 15985 "\2\2\u039a\u038e\3\2\2\2\u039a\u038f\3\2\2\2\u039a\u0390\3\2\2\2\u039a"+ 15986 "\u0391\3\2\2\2\u039a\u0392\3\2\2\2\u039a\u0393\3\2\2\2\u039a\u0395\3\2"+ 15987 "\2\2\u039a\u0396\3\2\2\2\u039a\u0397\3\2\2\2\u039a\u0398\3\2\2\2\u039a"+ 15988 "\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2"+ 15989 "\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a0\5@!\2\u03a0C"+ 15990 "\3\2\2\2\u03a1\u03a2\7\7\2\2\u03a2\u03a9\7F\2\2\u03a3\u03a8\5\n\6\2\u03a4"+ 15991 "\u03a8\7\b\2\2\u03a5\u03a8\7\3\2\2\u03a6\u03a8\7\6\2\2\u03a7\u03a3\3\2"+ 15992 "\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6\3\2\2\2\u03a8"+ 15993 "\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ac\3\2"+ 15994 "\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ad\79\2\2\u03adE\3\2\2\2\u03ae\u03af"+ 15995 "\7\7\2\2\u03af\u03b0\7;\2\2\u03b0\u03b4\7F\2\2\u03b1\u03b3\t\2\2\2\u03b2"+ 15996 "\u03b1\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2"+ 15997 "\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b8\79\2\2\u03b8"+ 15998 "G\3\2\2\2\u03b9\u03e1\5D#\2\u03ba\u03e0\5\f\7\2\u03bb\u03e0\5j\66\2\u03bc"+ 15999 "\u03e0\5\22\n\2\u03bd\u03e0\5\30\r\2\u03be\u03e0\5\36\20\2\u03bf\u03e0"+ 16000 "\5$\23\2\u03c0\u03e0\5*\26\2\u03c1\u03e0\5\60\31\2\u03c2\u03e0\5\66\34"+ 16001 "\2\u03c3\u03e0\5<\37\2\u03c4\u03e0\5B\"\2\u03c5\u03e0\5N(\2\u03c6\u03e0"+ 16002 "\5T+\2\u03c7\u03e0\5Z.\2\u03c8\u03e0\5f\64\2\u03c9\u03e0\5`\61\2\u03ca"+ 16003 "\u03e0\5\16\b\2\u03cb\u03e0\5\24\13\2\u03cc\u03e0\5\32\16\2\u03cd\u03e0"+ 16004 "\5 \21\2\u03ce\u03e0\5&\24\2\u03cf\u03e0\5,\27\2\u03d0\u03e0\5\62\32\2"+ 16005 "\u03d1\u03e0\58\35\2\u03d2\u03e0\5> \2\u03d3\u03e0\5J&\2\u03d4\u03e0\5"+ 16006 "P)\2\u03d5\u03e0\5V,\2\u03d6\u03e0\5b\62\2\u03d7\u03e0\5\\/\2\u03d8\u03d9"+ 16007 "\6%\16\2\u03d9\u03e0\7\3\2\2\u03da\u03e0\5\u0094K\2\u03db\u03e0\7\5\2"+ 16008 "\2\u03dc\u03e0\7\b\2\2\u03dd\u03e0\5\u0096L\2\u03de\u03e0\5\u0092J\2\u03df"+ 16009 "\u03ba\3\2\2\2\u03df\u03bb\3\2\2\2\u03df\u03bc\3\2\2\2\u03df\u03bd\3\2"+ 16010 "\2\2\u03df\u03be\3\2\2\2\u03df\u03bf\3\2\2\2\u03df\u03c0\3\2\2\2\u03df"+ 16011 "\u03c1\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03c3\3\2\2\2\u03df\u03c4\3\2"+ 16012 "\2\2\u03df\u03c5\3\2\2\2\u03df\u03c6\3\2\2\2\u03df\u03c7\3\2\2\2\u03df"+ 16013 "\u03c8\3\2\2\2\u03df\u03c9\3\2\2\2\u03df\u03ca\3\2\2\2\u03df\u03cb\3\2"+ 16014 "\2\2\u03df\u03cc\3\2\2\2\u03df\u03cd\3\2\2\2\u03df\u03ce\3\2\2\2\u03df"+ 16015 "\u03cf\3\2\2\2\u03df\u03d0\3\2\2\2\u03df\u03d1\3\2\2\2\u03df\u03d2\3\2"+ 16016 "\2\2\u03df\u03d3\3\2\2\2\u03df\u03d4\3\2\2\2\u03df\u03d5\3\2\2\2\u03df"+ 16017 "\u03d6\3\2\2\2\u03df\u03d7\3\2\2\2\u03df\u03d8\3\2\2\2\u03df\u03da\3\2"+ 16018 "\2\2\u03df\u03db\3\2\2\2\u03df\u03dc\3\2\2\2\u03df\u03dd\3\2\2\2\u03df"+ 16019 "\u03de\3\2\2\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2"+ 16020 "\2\2\u03e2\u03e4\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5F$\2\u03e5I"+ 16021 "\3\2\2\2\u03e6\u03e7\7\7\2\2\u03e7\u03ee\7G\2\2\u03e8\u03ed\5\n\6\2\u03e9"+ 16022 "\u03ed\7\b\2\2\u03ea\u03ed\7\3\2\2\u03eb\u03ed\7\6\2\2\u03ec\u03e8\3\2"+ 16023 "\2\2\u03ec\u03e9\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed"+ 16024 "\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f1\3\2"+ 16025 "\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03f2\79\2\2\u03f2K\3\2\2\2\u03f3\u03f4"+ 16026 "\7\7\2\2\u03f4\u03f5\7;\2\2\u03f5\u03f9\7G\2\2\u03f6\u03f8\t\2\2\2\u03f7"+ 16027 "\u03f6\3\2\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2"+ 16028 "\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03fd\79\2\2\u03fd"+ 16029 "M\3\2\2\2\u03fe\u0426\5J&\2\u03ff\u0425\5\f\7\2\u0400\u0425\5j\66\2\u0401"+ 16030 "\u0425\5\22\n\2\u0402\u0425\5\30\r\2\u0403\u0425\5\36\20\2\u0404\u0425"+ 16031 "\5$\23\2\u0405\u0425\5*\26\2\u0406\u0425\5\60\31\2\u0407\u0425\5\66\34"+ 16032 "\2\u0408\u0425\5<\37\2\u0409\u0425\5B\"\2\u040a\u0425\5H%\2\u040b\u0425"+ 16033 "\5T+\2\u040c\u0425\5Z.\2\u040d\u0425\5f\64\2\u040e\u0425\5`\61\2\u040f"+ 16034 "\u0425\5\16\b\2\u0410\u0425\5\24\13\2\u0411\u0425\5\32\16\2\u0412\u0425"+ 16035 "\5 \21\2\u0413\u0425\5&\24\2\u0414\u0425\5,\27\2\u0415\u0425\5\62\32\2"+ 16036 "\u0416\u0425\58\35\2\u0417\u0425\5> \2\u0418\u0425\5D#\2\u0419\u0425\5"+ 16037 "P)\2\u041a\u0425\5V,\2\u041b\u0425\5b\62\2\u041c\u0425\5\\/\2\u041d\u041e"+ 16038 "\6(\17\2\u041e\u0425\7\3\2\2\u041f\u0425\5\u0094K\2\u0420\u0425\7\5\2"+ 16039 "\2\u0421\u0425\7\b\2\2\u0422\u0425\5\u0096L\2\u0423\u0425\5\u0092J\2\u0424"+ 16040 "\u03ff\3\2\2\2\u0424\u0400\3\2\2\2\u0424\u0401\3\2\2\2\u0424\u0402\3\2"+ 16041 "\2\2\u0424\u0403\3\2\2\2\u0424\u0404\3\2\2\2\u0424\u0405\3\2\2\2\u0424"+ 16042 "\u0406\3\2\2\2\u0424\u0407\3\2\2\2\u0424\u0408\3\2\2\2\u0424\u0409\3\2"+ 16043 "\2\2\u0424\u040a\3\2\2\2\u0424\u040b\3\2\2\2\u0424\u040c\3\2\2\2\u0424"+ 16044 "\u040d\3\2\2\2\u0424\u040e\3\2\2\2\u0424\u040f\3\2\2\2\u0424\u0410\3\2"+ 16045 "\2\2\u0424\u0411\3\2\2\2\u0424\u0412\3\2\2\2\u0424\u0413\3\2\2\2\u0424"+ 16046 "\u0414\3\2\2\2\u0424\u0415\3\2\2\2\u0424\u0416\3\2\2\2\u0424\u0417\3\2"+ 16047 "\2\2\u0424\u0418\3\2\2\2\u0424\u0419\3\2\2\2\u0424\u041a\3\2\2\2\u0424"+ 16048 "\u041b\3\2\2\2\u0424\u041c\3\2\2\2\u0424\u041d\3\2\2\2\u0424\u041f\3\2"+ 16049 "\2\2\u0424\u0420\3\2\2\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424"+ 16050 "\u0423\3\2\2\2\u0425\u0428\3\2\2\2\u0426\u0424\3\2\2\2\u0426\u0427\3\2"+ 16051 "\2\2\u0427\u0429\3\2\2\2\u0428\u0426\3\2\2\2\u0429\u042a\5L\'\2\u042a"+ 16052 "O\3\2\2\2\u042b\u042c\7\7\2\2\u042c\u0433\7H\2\2\u042d\u0432\5\n\6\2\u042e"+ 16053 "\u0432\7\b\2\2\u042f\u0432\7\3\2\2\u0430\u0432\7\6\2\2\u0431\u042d\3\2"+ 16054 "\2\2\u0431\u042e\3\2\2\2\u0431\u042f\3\2\2\2\u0431\u0430\3\2\2\2\u0432"+ 16055 "\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0436\3\2"+ 16056 "\2\2\u0435\u0433\3\2\2\2\u0436\u0437\79\2\2\u0437Q\3\2\2\2\u0438\u0439"+ 16057 "\7\7\2\2\u0439\u043a\7;\2\2\u043a\u043e\7H\2\2\u043b\u043d\t\2\2\2\u043c"+ 16058 "\u043b\3\2\2\2\u043d\u0440\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2"+ 16059 "\2\2\u043f\u0441\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0442\79\2\2\u0442"+ 16060 "S\3\2\2\2\u0443\u046b\5P)\2\u0444\u046a\5\f\7\2\u0445\u046a\5j\66\2\u0446"+ 16061 "\u046a\5\22\n\2\u0447\u046a\5\30\r\2\u0448\u046a\5\36\20\2\u0449\u046a"+ 16062 "\5$\23\2\u044a\u046a\5*\26\2\u044b\u046a\5\60\31\2\u044c\u046a\5\66\34"+ 16063 "\2\u044d\u046a\5<\37\2\u044e\u046a\5B\"\2\u044f\u046a\5H%\2\u0450\u046a"+ 16064 "\5N(\2\u0451\u046a\5Z.\2\u0452\u046a\5f\64\2\u0453\u046a\5`\61\2\u0454"+ 16065 "\u046a\5\16\b\2\u0455\u046a\5\24\13\2\u0456\u046a\5\32\16\2\u0457\u046a"+ 16066 "\5 \21\2\u0458\u046a\5&\24\2\u0459\u046a\5,\27\2\u045a\u046a\5\62\32\2"+ 16067 "\u045b\u046a\58\35\2\u045c\u046a\5> \2\u045d\u046a\5D#\2\u045e\u046a\5"+ 16068 "J&\2\u045f\u046a\5V,\2\u0460\u046a\5b\62\2\u0461\u046a\5\\/\2\u0462\u0463"+ 16069 "\6+\20\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094K\2\u0465\u046a\7\5\2"+ 16070 "\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468\u046a\5\u0092J\2\u0469"+ 16071 "\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469\u0447\3\2"+ 16072 "\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2\2\2\u0469"+ 16073 "\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469\u044e\3\2"+ 16074 "\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2\2\2\u0469"+ 16075 "\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469\u0455\3\2"+ 16076 "\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2\2\2\u0469"+ 16077 "\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469\u045c\3\2"+ 16078 "\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2\2\2\u0469"+ 16079 "\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469\u0464\3\2"+ 16080 "\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2\2\2\u0469"+ 16081 "\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2"+ 16082 "\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5R*\2\u046fU"+ 16083 "\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7I\2\2\u0472\u0477\5\n\6\2\u0473"+ 16084 "\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476\u0472\3\2"+ 16085 "\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477"+ 16086 "\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u047b\3\2"+ 16087 "\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cW\3\2\2\2\u047d\u047e"+ 16088 "\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7I\2\2\u0480\u0482\t\2\2\2\u0481"+ 16089 "\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484\3\2"+ 16090 "\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+ 16091 "Y\3\2\2\2\u0488\u04b0\5V,\2\u0489\u04af\5\f\7\2\u048a\u04af\5j\66\2\u048b"+ 16092 "\u04af\5\22\n\2\u048c\u04af\5\30\r\2\u048d\u04af\5\36\20\2\u048e\u04af"+ 16093 "\5$\23\2\u048f\u04af\5*\26\2\u0490\u04af\5\60\31\2\u0491\u04af\5\66\34"+ 16094 "\2\u0492\u04af\5<\37\2\u0493\u04af\5B\"\2\u0494\u04af\5H%\2\u0495\u04af"+ 16095 "\5N(\2\u0496\u04af\5T+\2\u0497\u04af\5f\64\2\u0498\u04af\5`\61\2\u0499"+ 16096 "\u04af\5\16\b\2\u049a\u04af\5\24\13\2\u049b\u04af\5\32\16\2\u049c\u04af"+ 16097 "\5 \21\2\u049d\u04af\5&\24\2\u049e\u04af\5,\27\2\u049f\u04af\5\62\32\2"+ 16098 "\u04a0\u04af\58\35\2\u04a1\u04af\5> \2\u04a2\u04af\5D#\2\u04a3\u04af\5"+ 16099 "J&\2\u04a4\u04af\5P)\2\u04a5\u04af\5b\62\2\u04a6\u04af\5\\/\2\u04a7\u04a8"+ 16100 "\6.\21\2\u04a8\u04af\7\3\2\2\u04a9\u04af\5\u0094K\2\u04aa\u04af\7\5\2"+ 16101 "\2\u04ab\u04af\7\b\2\2\u04ac\u04af\5\u0096L\2\u04ad\u04af\5\u0092J\2\u04ae"+ 16102 "\u0489\3\2\2\2\u04ae\u048a\3\2\2\2\u04ae\u048b\3\2\2\2\u04ae\u048c\3\2"+ 16103 "\2\2\u04ae\u048d\3\2\2\2\u04ae\u048e\3\2\2\2\u04ae\u048f\3\2\2\2\u04ae"+ 16104 "\u0490\3\2\2\2\u04ae\u0491\3\2\2\2\u04ae\u0492\3\2\2\2\u04ae\u0493\3\2"+ 16105 "\2\2\u04ae\u0494\3\2\2\2\u04ae\u0495\3\2\2\2\u04ae\u0496\3\2\2\2\u04ae"+ 16106 "\u0497\3\2\2\2\u04ae\u0498\3\2\2\2\u04ae\u0499\3\2\2\2\u04ae\u049a\3\2"+ 16107 "\2\2\u04ae\u049b\3\2\2\2\u04ae\u049c\3\2\2\2\u04ae\u049d\3\2\2\2\u04ae"+ 16108 "\u049e\3\2\2\2\u04ae\u049f\3\2\2\2\u04ae\u04a0\3\2\2\2\u04ae\u04a1\3\2"+ 16109 "\2\2\u04ae\u04a2\3\2\2\2\u04ae\u04a3\3\2\2\2\u04ae\u04a4\3\2\2\2\u04ae"+ 16110 "\u04a5\3\2\2\2\u04ae\u04a6\3\2\2\2\u04ae\u04a7\3\2\2\2\u04ae\u04a9\3\2"+ 16111 "\2\2\u04ae\u04aa\3\2\2\2\u04ae\u04ab\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae"+ 16112 "\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b0\u04b1\3\2"+ 16113 "\2\2\u04b1\u04b3\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04b4\5X-\2\u04b4["+ 16114 "\3\2\2\2\u04b5\u04b6\7\7\2\2\u04b6\u04bd\7J\2\2\u04b7\u04bc\5\n\6\2\u04b8"+ 16115 "\u04bc\7\b\2\2\u04b9\u04bc\7\3\2\2\u04ba\u04bc\7\6\2\2\u04bb\u04b7\3\2"+ 16116 "\2\2\u04bb\u04b8\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bb\u04ba\3\2\2\2\u04bc"+ 16117 "\u04bf\3\2\2\2\u04bd\u04bb\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04c0\3\2"+ 16118 "\2\2\u04bf\u04bd\3\2\2\2\u04c0\u04c1\79\2\2\u04c1]\3\2\2\2\u04c2\u04c3"+ 16119 "\7\7\2\2\u04c3\u04c4\7;\2\2\u04c4\u04c8\7J\2\2\u04c5\u04c7\t\2\2\2\u04c6"+ 16120 "\u04c5\3\2\2\2\u04c7\u04ca\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c8\u04c9\3\2"+ 16121 "\2\2\u04c9\u04cb\3\2\2\2\u04ca\u04c8\3\2\2\2\u04cb\u04cc\79\2\2\u04cc"+ 16122 "_\3\2\2\2\u04cd\u04f5\5\\/\2\u04ce\u04f4\5\f\7\2\u04cf\u04f4\5j\66\2\u04d0"+ 16123 "\u04f4\5\22\n\2\u04d1\u04f4\5\30\r\2\u04d2\u04f4\5\36\20\2\u04d3\u04f4"+ 16124 "\5$\23\2\u04d4\u04f4\5*\26\2\u04d5\u04f4\5\60\31\2\u04d6\u04f4\5\66\34"+ 16125 "\2\u04d7\u04f4\5<\37\2\u04d8\u04f4\5B\"\2\u04d9\u04f4\5H%\2\u04da\u04f4"+ 16126 "\5N(\2\u04db\u04f4\5T+\2\u04dc\u04f4\5Z.\2\u04dd\u04f4\5f\64\2\u04de\u04f4"+ 16127 "\5\16\b\2\u04df\u04f4\5\24\13\2\u04e0\u04f4\5\32\16\2\u04e1\u04f4\5 \21"+ 16128 "\2\u04e2\u04f4\5&\24\2\u04e3\u04f4\5,\27\2\u04e4\u04f4\5\62\32\2\u04e5"+ 16129 "\u04f4\58\35\2\u04e6\u04f4\5> \2\u04e7\u04f4\5D#\2\u04e8\u04f4\5J&\2\u04e9"+ 16130 "\u04f4\5P)\2\u04ea\u04f4\5V,\2\u04eb\u04f4\5b\62\2\u04ec\u04ed\6\61\22"+ 16131 "\2\u04ed\u04f4\7\3\2\2\u04ee\u04f4\5\u0094K\2\u04ef\u04f4\7\5\2\2\u04f0"+ 16132 "\u04f4\7\b\2\2\u04f1\u04f4\5\u0096L\2\u04f2\u04f4\5\u0092J\2\u04f3\u04ce"+ 16133 "\3\2\2\2\u04f3\u04cf\3\2\2\2\u04f3\u04d0\3\2\2\2\u04f3\u04d1\3\2\2\2\u04f3"+ 16134 "\u04d2\3\2\2\2\u04f3\u04d3\3\2\2\2\u04f3\u04d4\3\2\2\2\u04f3\u04d5\3\2"+ 16135 "\2\2\u04f3\u04d6\3\2\2\2\u04f3\u04d7\3\2\2\2\u04f3\u04d8\3\2\2\2\u04f3"+ 16136 "\u04d9\3\2\2\2\u04f3\u04da\3\2\2\2\u04f3\u04db\3\2\2\2\u04f3\u04dc\3\2"+ 16137 "\2\2\u04f3\u04dd\3\2\2\2\u04f3\u04de\3\2\2\2\u04f3\u04df\3\2\2\2\u04f3"+ 16138 "\u04e0\3\2\2\2\u04f3\u04e1\3\2\2\2\u04f3\u04e2\3\2\2\2\u04f3\u04e3\3\2"+ 16139 "\2\2\u04f3\u04e4\3\2\2\2\u04f3\u04e5\3\2\2\2\u04f3\u04e6\3\2\2\2\u04f3"+ 16140 "\u04e7\3\2\2\2\u04f3\u04e8\3\2\2\2\u04f3\u04e9\3\2\2\2\u04f3\u04ea\3\2"+ 16141 "\2\2\u04f3\u04eb\3\2\2\2\u04f3\u04ec\3\2\2\2\u04f3\u04ee\3\2\2\2\u04f3"+ 16142 "\u04ef\3\2\2\2\u04f3\u04f0\3\2\2\2\u04f3\u04f1\3\2\2\2\u04f3\u04f2\3\2"+ 16143 "\2\2\u04f4\u04f7\3\2\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6"+ 16144 "\u04f8\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f8\u04f9\5^\60\2\u04f9a\3\2\2\2"+ 16145 "\u04fa\u04fb\7\7\2\2\u04fb\u0502\7K\2\2\u04fc\u0501\5\n\6\2\u04fd\u0501"+ 16146 "\7\b\2\2\u04fe\u0501\7\3\2\2\u04ff\u0501\7\6\2\2\u0500\u04fc\3\2\2\2\u0500"+ 16147 "\u04fd\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u04ff\3\2\2\2\u0501\u0504\3\2"+ 16148 "\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0505\3\2\2\2\u0504"+ 16149 "\u0502\3\2\2\2\u0505\u0506\79\2\2\u0506c\3\2\2\2\u0507\u0508\7\7\2\2\u0508"+ 16150 "\u0509\7;\2\2\u0509\u050d\7K\2\2\u050a\u050c\t\2\2\2\u050b\u050a\3\2\2"+ 16151 "\2\u050c\u050f\3\2\2\2\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u0510"+ 16152 "\3\2\2\2\u050f\u050d\3\2\2\2\u0510\u0511\79\2\2\u0511e\3\2\2\2\u0512\u053a"+ 16153 "\5b\62\2\u0513\u0539\5\f\7\2\u0514\u0539\5j\66\2\u0515\u0539\5\22\n\2"+ 16154 "\u0516\u0539\5\30\r\2\u0517\u0539\5\36\20\2\u0518\u0539\5$\23\2\u0519"+ 16155 "\u0539\5*\26\2\u051a\u0539\5\60\31\2\u051b\u0539\5\66\34\2\u051c\u0539"+ 16156 "\5<\37\2\u051d\u0539\5B\"\2\u051e\u0539\5H%\2\u051f\u0539\5N(\2\u0520"+ 16157 "\u0539\5T+\2\u0521\u0539\5Z.\2\u0522\u0539\5`\61\2\u0523\u0539\5\16\b"+ 16158 "\2\u0524\u0539\5\24\13\2\u0525\u0539\5\32\16\2\u0526\u0539\5 \21\2\u0527"+ 16159 "\u0539\5&\24\2\u0528\u0539\5,\27\2\u0529\u0539\5\62\32\2\u052a\u0539\5"+ 16160 "8\35\2\u052b\u0539\5> \2\u052c\u0539\5D#\2\u052d\u0539\5J&\2\u052e\u0539"+ 16161 "\5P)\2\u052f\u0539\5V,\2\u0530\u0539\5\\/\2\u0531\u0532\6\64\23\2\u0532"+ 16162 "\u0539\7\3\2\2\u0533\u0539\5\u0094K\2\u0534\u0539\7\5\2\2\u0535\u0539"+ 16163 "\7\b\2\2\u0536\u0539\5\u0096L\2\u0537\u0539\5\u0092J\2\u0538\u0513\3\2"+ 16164 "\2\2\u0538\u0514\3\2\2\2\u0538\u0515\3\2\2\2\u0538\u0516\3\2\2\2\u0538"+ 16165 "\u0517\3\2\2\2\u0538\u0518\3\2\2\2\u0538\u0519\3\2\2\2\u0538\u051a\3\2"+ 16166 "\2\2\u0538\u051b\3\2\2\2\u0538\u051c\3\2\2\2\u0538\u051d\3\2\2\2\u0538"+ 16167 "\u051e\3\2\2\2\u0538\u051f\3\2\2\2\u0538\u0520\3\2\2\2\u0538\u0521\3\2"+ 16168 "\2\2\u0538\u0522\3\2\2\2\u0538\u0523\3\2\2\2\u0538\u0524\3\2\2\2\u0538"+ 16169 "\u0525\3\2\2\2\u0538\u0526\3\2\2\2\u0538\u0527\3\2\2\2\u0538\u0528\3\2"+ 16170 "\2\2\u0538\u0529\3\2\2\2\u0538\u052a\3\2\2\2\u0538\u052b\3\2\2\2\u0538"+ 16171 "\u052c\3\2\2\2\u0538\u052d\3\2\2\2\u0538\u052e\3\2\2\2\u0538\u052f\3\2"+ 16172 "\2\2\u0538\u0530\3\2\2\2\u0538\u0531\3\2\2\2\u0538\u0533\3\2\2\2\u0538"+ 16173 "\u0534\3\2\2\2\u0538\u0535\3\2\2\2\u0538\u0536\3\2\2\2\u0538\u0537\3\2"+ 16174 "\2\2\u0539\u053c\3\2\2\2\u053a\u0538\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+ 16175 "\u053d\3\2\2\2\u053c\u053a\3\2\2\2\u053d\u053e\5d\63\2\u053eg\3\2\2\2"+ 16176 "\u053f\u054f\5j\66\2\u0540\u054f\5l\67\2\u0541\u054f\5n8\2\u0542\u054f"+ 16177 "\5p9\2\u0543\u054f\5r:\2\u0544\u054f\5t;\2\u0545\u054f\5v<\2\u0546\u054f"+ 16178 "\5x=\2\u0547\u054f\5z>\2\u0548\u054f\5|?\2\u0549\u054f\5~@\2\u054a\u054f"+ 16179 "\5\u0080A\2\u054b\u054f\5\u0082B\2\u054c\u054f\5\u0084C\2\u054d\u054f"+ 16180 "\5\u0086D\2\u054e\u053f\3\2\2\2\u054e\u0540\3\2\2\2\u054e\u0541\3\2\2"+ 16181 "\2\u054e\u0542\3\2\2\2\u054e\u0543\3\2\2\2\u054e\u0544\3\2\2\2\u054e\u0545"+ 16182 "\3\2\2\2\u054e\u0546\3\2\2\2\u054e\u0547\3\2\2\2\u054e\u0548\3\2\2\2\u054e"+ 16183 "\u0549\3\2\2\2\u054e\u054a\3\2\2\2\u054e\u054b\3\2\2\2\u054e\u054c\3\2"+ 16184 "\2\2\u054e\u054d\3\2\2\2\u054fi\3\2\2\2\u0550\u0551\7\7\2\2\u0551\u0558"+ 16185 "\t\3\2\2\u0552\u0557\5\n\6\2\u0553\u0557\7\b\2\2\u0554\u0557\7\3\2\2\u0555"+ 16186 "\u0557\7\6\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+ 16187 "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+ 16188 "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7:"+ 16189 "\2\2\u055ck\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7L\2\2\u055f\u0564"+ 16190 "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+ 16191 "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+ 16192 "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+ 16193 "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\t\4\2\2\u0569m\3\2\2\2"+ 16194 "\u056a\u056b\7\7\2\2\u056b\u0572\7M\2\2\u056c\u0571\5\n\6\2\u056d\u0571"+ 16195 "\7\b\2\2\u056e\u0571\7\3\2\2\u056f\u0571\7\6\2\2\u0570\u056c\3\2\2\2\u0570"+ 16196 "\u056d\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2"+ 16197 "\2\2\u0572\u0570\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574"+ 16198 "\u0572\3\2\2\2\u0575\u0576\t\4\2\2\u0576o\3\2\2\2\u0577\u0578\7\7\2\2"+ 16199 "\u0578\u057f\7N\2\2\u0579\u057e\5\n\6\2\u057a\u057e\7\b\2\2\u057b\u057e"+ 16200 "\7\3\2\2\u057c\u057e\7\6\2\2\u057d\u0579\3\2\2\2\u057d\u057a\3\2\2\2\u057d"+ 16201 "\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e\u0581\3\2\2\2\u057f\u057d\3\2"+ 16202 "\2\2\u057f\u0580\3\2\2\2\u0580\u0582\3\2\2\2\u0581\u057f\3\2\2\2\u0582"+ 16203 "\u0583\t\4\2\2\u0583q\3\2\2\2\u0584\u0585\7\7\2\2\u0585\u058c\7O\2\2\u0586"+ 16204 "\u058b\5\n\6\2\u0587\u058b\7\b\2\2\u0588\u058b\7\3\2\2\u0589\u058b\7\6"+ 16205 "\2\2\u058a\u0586\3\2\2\2\u058a\u0587\3\2\2\2\u058a\u0588\3\2\2\2\u058a"+ 16206 "\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2\2\2\u058c\u058d\3\2"+ 16207 "\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f\u0590\t\4\2\2\u0590"+ 16208 "s\3\2\2\2\u0591\u0592\7\7\2\2\u0592\u0599\7P\2\2\u0593\u0598\5\n\6\2\u0594"+ 16209 "\u0598\7\b\2\2\u0595\u0598\7\3\2\2\u0596\u0598\7\6\2\2\u0597\u0593\3\2"+ 16210 "\2\2\u0597\u0594\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0596\3\2\2\2\u0598"+ 16211 "\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c\3\2"+ 16212 "\2\2\u059b\u0599\3\2\2\2\u059c\u059d\t\4\2\2\u059du\3\2\2\2\u059e\u059f"+ 16213 "\7\7\2\2\u059f\u05a6\7Q\2\2\u05a0\u05a5\5\n\6\2\u05a1\u05a5\7\b\2\2\u05a2"+ 16214 "\u05a5\7\3\2\2\u05a3\u05a5\7\6\2\2\u05a4\u05a0\3\2\2\2\u05a4\u05a1\3\2"+ 16215 "\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3\3\2\2\2\u05a5\u05a8\3\2\2\2\u05a6"+ 16216 "\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a9\3\2\2\2\u05a8\u05a6\3\2"+ 16217 "\2\2\u05a9\u05aa\t\4\2\2\u05aaw\3\2\2\2\u05ab\u05ac\7\7\2\2\u05ac\u05b3"+ 16218 "\7R\2\2\u05ad\u05b2\5\n\6\2\u05ae\u05b2\7\b\2\2\u05af\u05b2\7\3\2\2\u05b0"+ 16219 "\u05b2\7\6\2\2\u05b1\u05ad\3\2\2\2\u05b1\u05ae\3\2\2\2\u05b1\u05af\3\2"+ 16220 "\2\2\u05b1\u05b0\3\2\2\2\u05b2\u05b5\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b3"+ 16221 "\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b3\3\2\2\2\u05b6\u05b7\t\4"+ 16222 "\2\2\u05b7y\3\2\2\2\u05b8\u05b9\7\7\2\2\u05b9\u05c0\7S\2\2\u05ba\u05bf"+ 16223 "\5\n\6\2\u05bb\u05bf\7\b\2\2\u05bc\u05bf\7\3\2\2\u05bd\u05bf\7\6\2\2\u05be"+ 16224 "\u05ba\3\2\2\2\u05be\u05bb\3\2\2\2\u05be\u05bc\3\2\2\2\u05be\u05bd\3\2"+ 16225 "\2\2\u05bf\u05c2\3\2\2\2\u05c0\u05be\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1"+ 16226 "\u05c3\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c3\u05c4\t\4\2\2\u05c4{\3\2\2\2"+ 16227 "\u05c5\u05c6\7\7\2\2\u05c6\u05cd\7T\2\2\u05c7\u05cc\5\n\6\2\u05c8\u05cc"+ 16228 "\7\b\2\2\u05c9\u05cc\7\3\2\2\u05ca\u05cc\7\6\2\2\u05cb\u05c7\3\2\2\2\u05cb"+ 16229 "\u05c8\3\2\2\2\u05cb\u05c9\3\2\2\2\u05cb\u05ca\3\2\2\2\u05cc\u05cf\3\2"+ 16230 "\2\2\u05cd\u05cb\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05d0\3\2\2\2\u05cf"+ 16231 "\u05cd\3\2\2\2\u05d0\u05d1\t\4\2\2\u05d1}\3\2\2\2\u05d2\u05d3\7\7\2\2"+ 16232 "\u05d3\u05da\7U\2\2\u05d4\u05d9\5\n\6\2\u05d5\u05d9\7\b\2\2\u05d6\u05d9"+ 16233 "\7\3\2\2\u05d7\u05d9\7\6\2\2\u05d8\u05d4\3\2\2\2\u05d8\u05d5\3\2\2\2\u05d8"+ 16234 "\u05d6\3\2\2\2\u05d8\u05d7\3\2\2\2\u05d9\u05dc\3\2\2\2\u05da\u05d8\3\2"+ 16235 "\2\2\u05da\u05db\3\2\2\2\u05db\u05dd\3\2\2\2\u05dc\u05da\3\2\2\2\u05dd"+ 16236 "\u05de\t\4\2\2\u05de\177\3\2\2\2\u05df\u05e0\7\7\2\2\u05e0\u05e7\7V\2"+ 16237 "\2\u05e1\u05e6\5\n\6\2\u05e2\u05e6\7\b\2\2\u05e3\u05e6\7\3\2\2\u05e4\u05e6"+ 16238 "\7\6\2\2\u05e5\u05e1\3\2\2\2\u05e5\u05e2\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5"+ 16239 "\u05e4\3\2\2\2\u05e6\u05e9\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e7\u05e8\3\2"+ 16240 "\2\2\u05e8\u05ea\3\2\2\2\u05e9\u05e7\3\2\2\2\u05ea\u05eb\t\4\2\2\u05eb"+ 16241 "\u0081\3\2\2\2\u05ec\u05ed\7\7\2\2\u05ed\u05f4\7W\2\2\u05ee\u05f3\5\n"+ 16242 "\6\2\u05ef\u05f3\7\b\2\2\u05f0\u05f3\7\3\2\2\u05f1\u05f3\7\6\2\2\u05f2"+ 16243 "\u05ee\3\2\2\2\u05f2\u05ef\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f1\3\2"+ 16244 "\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5"+ 16245 "\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\t\4\2\2\u05f8\u0083\3\2"+ 16246 "\2\2\u05f9\u05fa\7\7\2\2\u05fa\u0601\7X\2\2\u05fb\u0600\5\n\6\2\u05fc"+ 16247 "\u0600\7\b\2\2\u05fd\u0600\7\3\2\2\u05fe\u0600\7\6\2\2\u05ff\u05fb\3\2"+ 16248 "\2\2\u05ff\u05fc\3\2\2\2\u05ff\u05fd\3\2\2\2\u05ff\u05fe\3\2\2\2\u0600"+ 16249 "\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0604\3\2"+ 16250 "\2\2\u0603\u0601\3\2\2\2\u0604\u0605\t\4\2\2\u0605\u0085\3\2\2\2\u0606"+ 16251 "\u0607\7\7\2\2\u0607\u0608\7;\2\2\u0608\u0609\5\u0088E\2\u0609\u060a\7"+ 16252 "9\2\2\u060a\u060b\bD\1\2\u060b\u0087\3\2\2\2\u060c\u060d\t\5\2\2\u060d"+ 16253 "\u0089\3\2\2\2\u060e\u060f\6F\24\2\u060f\u0617\7\3\2\2\u0610\u0617\5\u0094"+ 16254 "K\2\u0611\u0617\7\5\2\2\u0612\u0617\7\b\2\2\u0613\u0617\5\u0096L\2\u0614"+ 16255 "\u0617\5\u0092J\2\u0615\u0617\5\4\3\2\u0616\u060e\3\2\2\2\u0616\u0610"+ 16256 "\3\2\2\2\u0616\u0611\3\2\2\2\u0616\u0612\3\2\2\2\u0616\u0613\3\2\2\2\u0616"+ 16257 "\u0614\3\2\2\2\u0616\u0615\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u0616\3\2"+ 16258 "\2\2\u0618\u0619\3\2\2\2\u0619\u008b\3\2\2\2\u061a\u061e\7\36\2\2\u061b"+ 16259 "\u061d\t\6\2\2\u061c\u061b\3\2\2\2\u061d\u0620\3\2\2\2\u061e\u061c\3\2"+ 16260 "\2\2\u061e\u061f\3\2\2\2\u061f\u0622\3\2\2\2\u0620\u061e\3\2\2\2\u0621"+ 16261 "\u0623\7 \2\2\u0622\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2"+ 16262 "\2\2\u0624\u0626\7#\2\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626"+ 16263 "\u0628\3\2\2\2\u0627\u0629\5\u008eH\2\u0628\u0627\3\2\2\2\u0628\u0629"+ 16264 "\3\2\2\2\u0629\u0640\3\2\2\2\u062a\u062c\t\6\2\2\u062b\u062a\3\2\2\2\u062c"+ 16265 "\u062d\3\2\2\2\u062d\u062b\3\2\2\2\u062d\u062e\3\2\2\2\u062e\u0630\3\2"+ 16266 "\2\2\u062f\u0631\7 \2\2\u0630\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631"+ 16267 "\u0633\3\2\2\2\u0632\u0634\7#\2\2\u0633\u0632\3\2\2\2\u0633\u0634\3\2"+ 16268 "\2\2\u0634\u0636\3\2\2\2\u0635\u0637\5\u008eH\2\u0636\u0635\3\2\2\2\u0636"+ 16269 "\u0637\3\2\2\2\u0637\u0640\3\2\2\2\u0638\u063a\7 \2\2\u0639\u0638\3\2"+ 16270 "\2\2\u0639\u063a\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063d\7#\2\2\u063c"+ 16271 "\u063e\5\u008eH\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0640"+ 16272 "\3\2\2\2\u063f\u061a\3\2\2\2\u063f\u062b\3\2\2\2\u063f\u0639\3\2\2\2\u0640"+ 16273 "\u008d\3\2\2\2\u0641\u0645\7$\2\2\u0642\u0644\t\7\2\2\u0643\u0642\3\2"+ 16274 "\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646"+ 16275 "\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649\7%\2\2\u0649\u008f\3\2"+ 16276 "\2\2\u064a\u064e\7\t\2\2\u064b\u064d\t\b\2\2\u064c\u064b\3\2\2\2\u064d"+ 16277 "\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f\3\2\2\2\u064f\u0652\3\2"+ 16278 "\2\2\u0650\u064e\3\2\2\2\u0651\u0653\5\u008aF\2\u0652\u0651\3\2\2\2\u0652"+ 16279 "\u0653\3\2\2\2\u0653\u070d\3\2\2\2\u0654\u0658\7\n\2\2\u0655\u0657\t\b"+ 16280 "\2\2\u0656\u0655\3\2\2\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+ 16281 "\u0659\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065b\u065d\5\u008a"+ 16282 "F\2\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u070d\3\2\2\2\u065e"+ 16283 "\u0662\7\13\2\2\u065f\u0661\t\b\2\2\u0660\u065f\3\2\2\2\u0661\u0664\3"+ 16284 "\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0666\3\2\2\2\u0664"+ 16285 "\u0662\3\2\2\2\u0665\u0667\7-\2\2\u0666\u0665\3\2\2\2\u0666\u0667\3\2"+ 16286 "\2\2\u0667\u066b\3\2\2\2\u0668\u066a\t\b\2\2\u0669\u0668\3\2\2\2\u066a"+ 16287 "\u066d\3\2\2\2\u066b\u0669\3\2\2\2\u066b\u066c\3\2\2\2\u066c\u066f\3\2"+ 16288 "\2\2\u066d\u066b\3\2\2\2\u066e\u0670\5\u008aF\2\u066f\u066e\3\2\2\2\u066f"+ 16289 "\u0670\3\2\2\2\u0670\u070d\3\2\2\2\u0671\u0675\7\f\2\2\u0672\u0674\t\b"+ 16290 "\2\2\u0673\u0672\3\2\2\2\u0674\u0677\3\2\2\2\u0675\u0673\3\2\2\2\u0675"+ 16291 "\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0675\3\2\2\2\u0678\u067a\7\33"+ 16292 "\2\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067e\3\2\2\2\u067b"+ 16293 "\u067d\t\b\2\2\u067c\u067b\3\2\2\2\u067d\u0680\3\2\2\2\u067e\u067c\3\2"+ 16294 "\2\2\u067e\u067f\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e\3\2\2\2\u0681"+ 16295 "\u0683\5\u008aF\2\u0682\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u070d"+ 16296 "\3\2\2\2\u0684\u0688\7\r\2\2\u0685\u0687\t\b\2\2\u0686\u0685\3\2\2\2\u0687"+ 16297 "\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068c\3\2"+ 16298 "\2\2\u068a\u0688\3\2\2\2\u068b\u068d\5\u008aF\2\u068c\u068b\3\2\2\2\u068c"+ 16299 "\u068d\3\2\2\2\u068d\u070d\3\2\2\2\u068e\u0692\7\16\2\2\u068f\u0691\t"+ 16300 "\b\2\2\u0690\u068f\3\2\2\2\u0691\u0694\3\2\2\2\u0692\u0690\3\2\2\2\u0692"+ 16301 "\u0693\3\2\2\2\u0693\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695\u0697\5\u008c"+ 16302 "G\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069c\3\2\2\2\u0698"+ 16303 "\u069b\7\35\2\2\u0699\u069b\5\4\3\2\u069a\u0698\3\2\2\2\u069a\u0699\3"+ 16304 "\2\2\2\u069b\u069e\3\2\2\2\u069c\u069a\3\2\2\2\u069c\u069d\3\2\2\2\u069d"+ 16305 "\u06a2\3\2\2\2\u069e\u069c\3\2\2\2\u069f\u06a1\t\b\2\2\u06a0\u069f\3\2"+ 16306 "\2\2\u06a1\u06a4\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3"+ 16307 "\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a5\u06a7\5\u008aF\2\u06a6\u06a5"+ 16308 "\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u070d\3\2\2\2\u06a8\u06ac\7\17\2\2"+ 16309 "\u06a9\u06ab\t\b\2\2\u06aa\u06a9\3\2\2\2\u06ab\u06ae\3\2\2\2\u06ac\u06aa"+ 16310 "\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06b0\3\2\2\2\u06ae\u06ac\3\2\2\2\u06af"+ 16311 "\u06b1\t\t\2\2\u06b0\u06af\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b3\3\2"+ 16312 "\2\2\u06b2\u06b4\5\u008aF\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4"+ 16313 "\u070d\3\2\2\2\u06b5\u06b9\7\21\2\2\u06b6\u06b8\t\b\2\2\u06b7\u06b6\3"+ 16314 "\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba"+ 16315 "\u06bd\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5\u008aF\2\u06bd\u06bc"+ 16316 "\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u070d\3\2\2\2\u06bf\u06c3\7\20\2\2"+ 16317 "\u06c0\u06c2\t\b\2\2\u06c1\u06c0\3\2\2\2\u06c2\u06c5\3\2\2\2\u06c3\u06c1"+ 16318 "\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2\2\2\u06c6"+ 16319 "\u06c8\7)\2\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cc\3\2"+ 16320 "\2\2\u06c9\u06cb\t\b\2\2\u06ca\u06c9\3\2\2\2\u06cb\u06ce\3\2\2\2\u06cc"+ 16321 "\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06d0\3\2\2\2\u06ce\u06cc\3\2"+ 16322 "\2\2\u06cf\u06d1\7+\2\2\u06d0\u06cf\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1"+ 16323 "\u06d5\3\2\2\2\u06d2\u06d4\t\b\2\2\u06d3\u06d2\3\2\2\2\u06d4\u06d7\3\2"+ 16324 "\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d9\3\2\2\2\u06d7"+ 16325 "\u06d5\3\2\2\2\u06d8\u06da\5\u008aF\2\u06d9\u06d8\3\2\2\2\u06d9\u06da"+ 16326 "\3\2\2\2\u06da\u070d\3\2\2\2\u06db\u06df\7\22\2\2\u06dc\u06de\t\b\2\2"+ 16327 "\u06dd\u06dc\3\2\2\2\u06de\u06e1\3\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06e0"+ 16328 "\3\2\2\2\u06e0\u06e3\3\2\2\2\u06e1\u06df\3\2\2\2\u06e2\u06e4\5\u008aF"+ 16329 "\2\u06e3\u06e2\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u070d\3\2\2\2\u06e5\u06e9"+ 16330 "\7\23\2\2\u06e6\u06e8\t\b\2\2\u06e7\u06e6\3\2\2\2\u06e8\u06eb\3\2\2\2"+ 16331 "\u06e9\u06e7\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb\u06e9"+ 16332 "\3\2\2\2\u06ec\u06ee\7-\2\2\u06ed\u06ec\3\2\2\2\u06ed\u06ee\3\2\2\2\u06ee"+ 16333 "\u06f2\3\2\2\2\u06ef\u06f1\t\b\2\2\u06f0\u06ef\3\2\2\2\u06f1\u06f4\3\2"+ 16334 "\2\2\u06f2\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f6\3\2\2\2\u06f4"+ 16335 "\u06f2\3\2\2\2\u06f5\u06f7\5\u008aF\2\u06f6\u06f5\3\2\2\2\u06f6\u06f7"+ 16336 "\3\2\2\2\u06f7\u070d\3\2\2\2\u06f8\u06fc\7\24\2\2\u06f9\u06fb\t\b\2\2"+ 16337 "\u06fa\u06f9\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd"+ 16338 "\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06ff\u0701\5\u008aF"+ 16339 "\2\u0700\u06ff\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u070d\3\2\2\2\u0702\u0706"+ 16340 "\7\27\2\2\u0703\u0705\t\b\2\2\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2"+ 16341 "\u0706\u0704\3\2\2\2\u0706\u0707\3\2\2\2\u0707\u070a\3\2\2\2\u0708\u0706"+ 16342 "\3\2\2\2\u0709\u070b\5\u008aF\2\u070a\u0709\3\2\2\2\u070a\u070b\3\2\2"+ 16343 "\2\u070b\u070d\3\2\2\2\u070c\u064a\3\2\2\2\u070c\u0654\3\2\2\2\u070c\u065e"+ 16344 "\3\2\2\2\u070c\u0671\3\2\2\2\u070c\u0684\3\2\2\2\u070c\u068e\3\2\2\2\u070c"+ 16345 "\u06a8\3\2\2\2\u070c\u06b5\3\2\2\2\u070c\u06bf\3\2\2\2\u070c\u06db\3\2"+ 16346 "\2\2\u070c\u06e5\3\2\2\2\u070c\u06f8\3\2\2\2\u070c\u0702\3\2\2\2\u070d"+ 16347 "\u0091\3\2\2\2\u070e\u075a\7\25\2\2\u070f\u0716\7/\2\2\u0710\u0715\7\6"+ 16348 "\2\2\u0711\u0715\7\b\2\2\u0712\u0715\7\3\2\2\u0713\u0715\5\u0096L\2\u0714"+ 16349 "\u0710\3\2\2\2\u0714\u0711\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0713\3\2"+ 16350 "\2\2\u0715\u0718\3\2\2\2\u0716\u0714\3\2\2\2\u0716\u0717\3\2\2\2\u0717"+ 16351 "\u075b\3\2\2\2\u0718\u0716\3\2\2\2\u0719\u071d\7\60\2\2\u071a\u071c\t"+ 16352 "\2\2\2\u071b\u071a\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2\2\2\u071d"+ 16353 "\u071e\3\2\2\2\u071e\u075b\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0724\7\61"+ 16354 "\2\2\u0721\u0723\t\2\2\2\u0722\u0721\3\2\2\2\u0723\u0726\3\2\2\2\u0724"+ 16355 "\u0722\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u075b\3\2\2\2\u0726\u0724\3\2"+ 16356 "\2\2\u0727\u072b\7\62\2\2\u0728\u072a\t\2\2\2\u0729\u0728\3\2\2\2\u072a"+ 16357 "\u072d\3\2\2\2\u072b\u0729\3\2\2\2\u072b\u072c\3\2\2\2\u072c\u072e\3\2"+ 16358 "\2\2\u072d\u072b\3\2\2\2\u072e\u0730\5\u008cG\2\u072f\u0731\5\u008aF\2"+ 16359 "\u0730\u072f\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u075b\3\2\2\2\u0732\u0736"+ 16360 "\7\63\2\2\u0733\u0735\t\2\2\2\u0734\u0733\3\2\2\2\u0735\u0738\3\2\2\2"+ 16361 "\u0736\u0734\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u0739\3\2\2\2\u0738\u0736"+ 16362 "\3\2\2\2\u0739\u073b\5\u008cG\2\u073a\u073c\5\u008aF\2\u073b\u073a\3\2"+ 16363 "\2\2\u073b\u073c\3\2\2\2\u073c\u075b\3\2\2\2\u073d\u0744\7\64\2\2\u073e"+ 16364 "\u0743\7\6\2\2\u073f\u0743\7\b\2\2\u0740\u0743\7\3\2\2\u0741\u0743\5\u0096"+ 16365 "L\2\u0742\u073e\3\2\2\2\u0742\u073f\3\2\2\2\u0742\u0740\3\2\2\2\u0742"+ 16366 "\u0741\3\2\2\2\u0743\u0746\3\2\2\2\u0744\u0742\3\2\2\2\u0744\u0745\3\2"+ 16367 "\2\2\u0745\u075b\3\2\2\2\u0746\u0744\3\2\2\2\u0747\u074b\7\65\2\2\u0748"+ 16368 "\u074a\t\2\2\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749\3\2"+ 16369 "\2\2\u074b\u074c\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+ 16370 "\u0750\5\u008cG\2\u074f\u074e\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u075b"+ 16371 "\3\2\2\2\u0751\u0753\7\27\2\2\u0752\u0754\t\2\2\2\u0753\u0752\3\2\2\2"+ 16372 "\u0754\u0755\3\2\2\2\u0755\u0753\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0758"+ 16373 "\3\2\2\2\u0757\u0759\5\u008aF\2\u0758\u0757\3\2\2\2\u0758\u0759\3\2\2"+ 16374 "\2\u0759\u075b\3\2\2\2\u075a\u070f\3\2\2\2\u075a\u0719\3\2\2\2\u075a\u0720"+ 16375 "\3\2\2\2\u075a\u0727\3\2\2\2\u075a\u0732\3\2\2\2\u075a\u073d\3\2\2\2\u075a"+ 16376 "\u0747\3\2\2\2\u075a\u0751\3\2\2\2\u075b\u075c\3\2\2\2\u075c\u075d\7\26"+ 16377 "\2\2\u075d\u0093\3\2\2\2\u075e\u0764\7\4\2\2\u075f\u0763\5\u0096L\2\u0760"+ 16378 "\u0763\7\b\2\2\u0761\u0763\7\3\2\2\u0762\u075f\3\2\2\2\u0762\u0760\3\2"+ 16379 "\2\2\u0762\u0761\3\2\2\2\u0763\u0766\3\2\2\2\u0764\u0762\3\2\2\2\u0764"+ 16380 "\u0765\3\2\2\2\u0765\u0767\3\2\2\2\u0766\u0764\3\2\2\2\u0767\u0768\7]"+ 16381 "\2\2\u0768\u0095\3\2\2\2\u0769\u076b\t\n\2\2\u076a\u0769\3\2\2\2\u076b"+ 16382 "\u076c\3\2\2\2\u076c\u076a\3\2\2\2\u076c\u076d\3\2\2\2\u076d\u0097\3\2"+ 16383 "\2\2\u00c5\u00a0\u00a2\u00a6\u00ab\u00b1\u00e5\u00ed\u00ef\u00fa\u0103"+ 16384 "\u010a\u0110\u011b\u011d\u012b\u012d\u0132\u013a\u013c\u0147\u0172\u0174"+ 16385 "\u017f\u0181\u018c\u01b7\u01b9\u01c4\u01c6\u01d1\u01fc\u01fe\u0209\u020b"+ 16386 "\u0216\u0241\u0243\u024e\u0250\u025b\u0286\u0288\u0293\u0295\u02a0\u02cb"+ 16387 "\u02cd\u02d8\u02da\u02e5\u0310\u0312\u031d\u031f\u032a\u0355\u0357\u0362"+ 16388 "\u0364\u036f\u039a\u039c\u03a7\u03a9\u03b4\u03df\u03e1\u03ec\u03ee\u03f9"+ 16389 "\u0424\u0426\u0431\u0433\u043e\u0469\u046b\u0476\u0478\u0483\u04ae\u04b0"+ 16390 "\u04bb\u04bd\u04c8\u04f3\u04f5\u0500\u0502\u050d\u0538\u053a\u054e\u0556"+ 16391 "\u0558\u0563\u0565\u0570\u0572\u057d\u057f\u058a\u058c\u0597\u0599\u05a4"+ 16392 "\u05a6\u05b1\u05b3\u05be\u05c0\u05cb\u05cd\u05d8\u05da\u05e5\u05e7\u05f2"+ 16393 "\u05f4\u05ff\u0601\u0616\u0618\u061e\u0622\u0625\u0628\u062d\u0630\u0633"+ 16394 "\u0636\u0639\u063d\u063f\u0645\u064e\u0652\u0658\u065c\u0662\u0666\u066b"+ 16395 "\u066f\u0675\u0679\u067e\u0682\u0688\u068c\u0692\u0696\u069a\u069c\u06a2"+ 16396 "\u06a6\u06ac\u06b0\u06b3\u06b9\u06bd\u06c3\u06c7\u06cc\u06d0\u06d5\u06d9"+ 16397 "\u06df\u06e3\u06e9\u06ed\u06f2\u06f6\u06fc\u0700\u0706\u070a\u070c\u0714"+ 16398 "\u0716\u071d\u0724\u072b\u0730\u0736\u073b\u0742\u0744\u074b\u074f\u0755"+ 16399 "\u0758\u075a\u0762\u0764\u076c"; 16400 public static final ATN _ATN = 16401 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 16402 static { 16403 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; 16404 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { 16405 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); 16406 } 16407 } 16408}