001// Generated from com/puppycrawl/tools/checkstyle/grammars/javadoc/JavadocParser.g4 by ANTLR 4.9.2 002package com.puppycrawl.tools.checkstyle.grammars.javadoc; 003import org.antlr.v4.runtime.atn.*; 004import org.antlr.v4.runtime.dfa.DFA; 005import org.antlr.v4.runtime.*; 006import org.antlr.v4.runtime.misc.*; 007import org.antlr.v4.runtime.tree.*; 008import java.util.List; 009import java.util.Iterator; 010import java.util.ArrayList; 011 012@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) 013public class JavadocParser extends Parser { 014 static { RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); } 015 016 protected static final DFA[] _decisionToDFA; 017 protected static final PredictionContextCache _sharedContextCache = 018 new PredictionContextCache(); 019 public static final int 020 LEADING_ASTERISK=1, HTML_COMMENT_START=2, CDATA=3, WS=4, OPEN=5, NEWLINE=6, 021 AUTHOR_LITERAL=7, DEPRECATED_LITERAL=8, EXCEPTION_LITERAL=9, PARAM_LITERAL=10, 022 RETURN_LITERAL=11, SEE_LITERAL=12, SERIAL_LITERAL=13, SERIAL_FIELD_LITERAL=14, 023 SERIAL_DATA_LITERAL=15, SINCE_LITERAL=16, THROWS_LITERAL=17, VERSION_LITERAL=18, 024 JAVADOC_INLINE_TAG_START=19, JAVADOC_INLINE_TAG_END=20, CUSTOM_NAME=21, 025 LITERAL_INCLUDE=22, LITERAL_EXCLUDE=23, CHAR=24, PARAMETER_NAME=25, Char1=26, 026 STRING=27, PACKAGE=28, DOT=29, HASH=30, CLASS=31, Char2=32, MEMBER=33, 027 LEFT_BRACE=34, RIGHT_BRACE=35, ARGUMENT=36, COMMA=37, Char20=38, FIELD_NAME=39, 028 Char3=40, FIELD_TYPE=41, Char4=42, CLASS_NAME=43, Char5=44, CODE_LITERAL=45, 029 DOC_ROOT_LITERAL=46, INHERIT_DOC_LITERAL=47, LINK_LITERAL=48, LINKPLAIN_LITERAL=49, 030 LITERAL_LITERAL=50, VALUE_LITERAL=51, Char7=52, Char8=53, Char10=54, CLOSE=55, 031 SLASH_CLOSE=56, SLASH=57, EQUALS=58, P_HTML_TAG_NAME=59, LI_HTML_TAG_NAME=60, 032 TR_HTML_TAG_NAME=61, TD_HTML_TAG_NAME=62, TH_HTML_TAG_NAME=63, BODY_HTML_TAG_NAME=64, 033 COLGROUP_HTML_TAG_NAME=65, DD_HTML_TAG_NAME=66, DT_HTML_TAG_NAME=67, HEAD_HTML_TAG_NAME=68, 034 HTML_HTML_TAG_NAME=69, OPTION_HTML_TAG_NAME=70, TBODY_HTML_TAG_NAME=71, 035 TFOOT_HTML_TAG_NAME=72, THEAD_HTML_TAG_NAME=73, AREA_HTML_TAG_NAME=74, 036 BASE_HTML_TAG_NAME=75, BASEFONT_HTML_TAG_NAME=76, BR_HTML_TAG_NAME=77, 037 COL_HTML_TAG_NAME=78, FRAME_HTML_TAG_NAME=79, HR_HTML_TAG_NAME=80, IMG_HTML_TAG_NAME=81, 038 INPUT_HTML_TAG_NAME=82, ISINDEX_HTML_TAG_NAME=83, LINK_HTML_TAG_NAME=84, 039 META_HTML_TAG_NAME=85, PARAM_HTML_TAG_NAME=86, HTML_TAG_NAME=87, Char11=88, 040 ATTR_VALUE=89, Char12=90, HTML_COMMENT_END=91; 041 public static final int 042 RULE_javadoc = 0, RULE_htmlElement = 1, RULE_htmlElementOpen = 2, RULE_htmlElementClose = 3, 043 RULE_attribute = 4, RULE_htmlTag = 5, RULE_pTagOpen = 6, RULE_pTagClose = 7, 044 RULE_paragraph = 8, RULE_liTagOpen = 9, RULE_liTagClose = 10, RULE_li = 11, 045 RULE_trTagOpen = 12, RULE_trTagClose = 13, RULE_tr = 14, RULE_tdTagOpen = 15, 046 RULE_tdTagClose = 16, RULE_td = 17, RULE_thTagOpen = 18, RULE_thTagClose = 19, 047 RULE_th = 20, RULE_bodyTagOpen = 21, RULE_bodyTagClose = 22, RULE_body = 23, 048 RULE_colgroupTagOpen = 24, RULE_colgroupTagClose = 25, RULE_colgroup = 26, 049 RULE_ddTagOpen = 27, RULE_ddTagClose = 28, RULE_dd = 29, RULE_dtTagOpen = 30, 050 RULE_dtTagClose = 31, RULE_dt = 32, RULE_headTagOpen = 33, RULE_headTagClose = 34, 051 RULE_head = 35, RULE_htmlTagOpen = 36, RULE_htmlTagClose = 37, RULE_html = 38, 052 RULE_optionTagOpen = 39, RULE_optionTagClose = 40, RULE_option = 41, RULE_tbodyTagOpen = 42, 053 RULE_tbodyTagClose = 43, RULE_tbody = 44, RULE_tfootTagOpen = 45, RULE_tfootTagClose = 46, 054 RULE_tfoot = 47, RULE_theadTagOpen = 48, RULE_theadTagClose = 49, RULE_thead = 50, 055 RULE_singletonElement = 51, RULE_singletonTag = 52, RULE_areaTag = 53, 056 RULE_baseTag = 54, RULE_basefontTag = 55, RULE_brTag = 56, RULE_colTag = 57, 057 RULE_frameTag = 58, RULE_hrTag = 59, RULE_imgTag = 60, RULE_inputTag = 61, 058 RULE_isindexTag = 62, RULE_linkTag = 63, RULE_metaTag = 64, RULE_paramTag = 65, 059 RULE_wrongSinletonTag = 66, RULE_singletonTagName = 67, RULE_description = 68, 060 RULE_reference = 69, RULE_parameters = 70, RULE_javadocTag = 71, RULE_javadocInlineTag = 72, 061 RULE_htmlComment = 73, RULE_text = 74; 062 private static String[] makeRuleNames() { 063 return new String[] { 064 "javadoc", "htmlElement", "htmlElementOpen", "htmlElementClose", "attribute", 065 "htmlTag", "pTagOpen", "pTagClose", "paragraph", "liTagOpen", "liTagClose", 066 "li", "trTagOpen", "trTagClose", "tr", "tdTagOpen", "tdTagClose", "td", 067 "thTagOpen", "thTagClose", "th", "bodyTagOpen", "bodyTagClose", "body", 068 "colgroupTagOpen", "colgroupTagClose", "colgroup", "ddTagOpen", "ddTagClose", 069 "dd", "dtTagOpen", "dtTagClose", "dt", "headTagOpen", "headTagClose", 070 "head", "htmlTagOpen", "htmlTagClose", "html", "optionTagOpen", "optionTagClose", 071 "option", "tbodyTagOpen", "tbodyTagClose", "tbody", "tfootTagOpen", "tfootTagClose", 072 "tfoot", "theadTagOpen", "theadTagClose", "thead", "singletonElement", 073 "singletonTag", "areaTag", "baseTag", "basefontTag", "brTag", "colTag", 074 "frameTag", "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", 075 "paramTag", "wrongSinletonTag", "singletonTagName", "description", "reference", 076 "parameters", "javadocTag", "javadocInlineTag", "htmlComment", "text" 077 }; 078 } 079 public static final String[] ruleNames = makeRuleNames(); 080 081 private static String[] makeLiteralNames() { 082 return new String[] { 083 null, null, null, null, null, null, null, "'@author'", "'@deprecated'", 084 null, null, "'@return'", null, "'@serial'", null, "'@serialData'", "'@since'", 085 null, "'@version'", null, null, null, "'include'", "'exclude'", null, 086 null, null, null, null, "'.'", null, null, null, null, "'('", "')'", 087 null, "','", null, null, null, null, null, null, null, null, "'@docRoot'", 088 "'@inheritDoc'", "'@link'", "'@linkplain'", null, "'@value'", null, null, 089 null, null, null, "'/'", "'='", null, null, null, null, null, null, null, 090 null, null, null, null, null, null, null, null, null, null, null, null, 091 null, null, null, null, null, null, null, null, null, null, null, null, 092 null, "'-->'" 093 }; 094 } 095 private static final String[] _LITERAL_NAMES = makeLiteralNames(); 096 private static String[] makeSymbolicNames() { 097 return new String[] { 098 null, "LEADING_ASTERISK", "HTML_COMMENT_START", "CDATA", "WS", "OPEN", 099 "NEWLINE", "AUTHOR_LITERAL", "DEPRECATED_LITERAL", "EXCEPTION_LITERAL", 100 "PARAM_LITERAL", "RETURN_LITERAL", "SEE_LITERAL", "SERIAL_LITERAL", "SERIAL_FIELD_LITERAL", 101 "SERIAL_DATA_LITERAL", "SINCE_LITERAL", "THROWS_LITERAL", "VERSION_LITERAL", 102 "JAVADOC_INLINE_TAG_START", "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", 103 "LITERAL_INCLUDE", "LITERAL_EXCLUDE", "CHAR", "PARAMETER_NAME", "Char1", 104 "STRING", "PACKAGE", "DOT", "HASH", "CLASS", "Char2", "MEMBER", "LEFT_BRACE", 105 "RIGHT_BRACE", "ARGUMENT", "COMMA", "Char20", "FIELD_NAME", "Char3", 106 "FIELD_TYPE", "Char4", "CLASS_NAME", "Char5", "CODE_LITERAL", "DOC_ROOT_LITERAL", 107 "INHERIT_DOC_LITERAL", "LINK_LITERAL", "LINKPLAIN_LITERAL", "LITERAL_LITERAL", 108 "VALUE_LITERAL", "Char7", "Char8", "Char10", "CLOSE", "SLASH_CLOSE", 109 "SLASH", "EQUALS", "P_HTML_TAG_NAME", "LI_HTML_TAG_NAME", "TR_HTML_TAG_NAME", 110 "TD_HTML_TAG_NAME", "TH_HTML_TAG_NAME", "BODY_HTML_TAG_NAME", "COLGROUP_HTML_TAG_NAME", 111 "DD_HTML_TAG_NAME", "DT_HTML_TAG_NAME", "HEAD_HTML_TAG_NAME", "HTML_HTML_TAG_NAME", 112 "OPTION_HTML_TAG_NAME", "TBODY_HTML_TAG_NAME", "TFOOT_HTML_TAG_NAME", 113 "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", "BASE_HTML_TAG_NAME", "BASEFONT_HTML_TAG_NAME", 114 "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", "FRAME_HTML_TAG_NAME", "HR_HTML_TAG_NAME", 115 "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", "ISINDEX_HTML_TAG_NAME", 116 "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", "HTML_TAG_NAME", 117 "Char11", "ATTR_VALUE", "Char12", "HTML_COMMENT_END" 118 }; 119 } 120 private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); 121 public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); 122 123 /** 124 * @deprecated Use {@link #VOCABULARY} instead. 125 */ 126 @Deprecated 127 public static final String[] tokenNames; 128 static { 129 tokenNames = new String[_SYMBOLIC_NAMES.length]; 130 for (int i = 0; i < tokenNames.length; i++) { 131 tokenNames[i] = VOCABULARY.getLiteralName(i); 132 if (tokenNames[i] == null) { 133 tokenNames[i] = VOCABULARY.getSymbolicName(i); 134 } 135 136 if (tokenNames[i] == null) { 137 tokenNames[i] = "<INVALID>"; 138 } 139 } 140 } 141 142 @Override 143 @Deprecated 144 public String[] getTokenNames() { 145 return tokenNames; 146 } 147 148 @Override 149 150 public Vocabulary getVocabulary() { 151 return VOCABULARY; 152 } 153 154 @Override 155 public String getGrammarFileName() { return "JavadocParser.g4"; } 156 157 @Override 158 public String[] getRuleNames() { return ruleNames; } 159 160 @Override 161 public String getSerializedATN() { return _serializedATN; } 162 163 @Override 164 public ATN getATN() { return _ATN; } 165 166 167 boolean isNextJavadocTag() { 168 int token1 = _input.LA(2); 169 int token2 = _input.LA(3); 170 return isJavadocTag(token1) 171 || (token1 == WS && isJavadocTag(token2)); 172 } 173 174 boolean isJavadocTag(int type) { 175 switch(type) { 176 case AUTHOR_LITERAL: 177 case DEPRECATED_LITERAL: 178 case EXCEPTION_LITERAL: 179 case PARAM_LITERAL: 180 case RETURN_LITERAL: 181 case SEE_LITERAL: 182 case SERIAL_LITERAL: 183 case SERIAL_FIELD_LITERAL: 184 case SERIAL_DATA_LITERAL: 185 case SINCE_LITERAL: 186 case THROWS_LITERAL: 187 case VERSION_LITERAL: 188 case CUSTOM_NAME: 189 return true; 190 default: 191 return false; 192 } 193 } 194 195 boolean isSameTagNames(ParserRuleContext htmlTagOpen, ParserRuleContext htmlTagClose) { 196 String openTag = htmlTagOpen.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 197 String closeTag = htmlTagClose.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 198 System.out.println(openTag + " - " + closeTag); 199 return openTag.equals(closeTag); 200 } 201 202 public JavadocParser(TokenStream input) { 203 super(input); 204 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); 205 } 206 public static class JavadocContext extends ParserRuleContext { 207 public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); } 208 public List<HtmlElementContext> htmlElement() { 209 return getRuleContexts(HtmlElementContext.class); 210 } 211 public HtmlElementContext htmlElement(int i) { 212 return getRuleContext(HtmlElementContext.class,i); 213 } 214 public List<HtmlCommentContext> htmlComment() { 215 return getRuleContexts(HtmlCommentContext.class); 216 } 217 public HtmlCommentContext htmlComment(int i) { 218 return getRuleContext(HtmlCommentContext.class,i); 219 } 220 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 221 public TerminalNode CDATA(int i) { 222 return getToken(JavadocParser.CDATA, i); 223 } 224 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 225 public TerminalNode NEWLINE(int i) { 226 return getToken(JavadocParser.NEWLINE, i); 227 } 228 public List<TextContext> text() { 229 return getRuleContexts(TextContext.class); 230 } 231 public TextContext text(int i) { 232 return getRuleContext(TextContext.class,i); 233 } 234 public List<JavadocInlineTagContext> javadocInlineTag() { 235 return getRuleContexts(JavadocInlineTagContext.class); 236 } 237 public JavadocInlineTagContext javadocInlineTag(int i) { 238 return getRuleContext(JavadocInlineTagContext.class,i); 239 } 240 public List<JavadocTagContext> javadocTag() { 241 return getRuleContexts(JavadocTagContext.class); 242 } 243 public JavadocTagContext javadocTag(int i) { 244 return getRuleContext(JavadocTagContext.class,i); 245 } 246 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 247 public TerminalNode LEADING_ASTERISK(int i) { 248 return getToken(JavadocParser.LEADING_ASTERISK, i); 249 } 250 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 251 public TerminalNode WS(int i) { 252 return getToken(JavadocParser.WS, i); 253 } 254 public JavadocContext(ParserRuleContext parent, int invokingState) { 255 super(parent, invokingState); 256 } 257 @Override public int getRuleIndex() { return RULE_javadoc; } 258 @Override 259 public void enterRule(ParseTreeListener listener) { 260 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadoc(this); 261 } 262 @Override 263 public void exitRule(ParseTreeListener listener) { 264 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadoc(this); 265 } 266 @Override 267 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 268 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadoc(this); 269 else return visitor.visitChildren(this); 270 } 271 } 272 273 public final JavadocContext javadoc() throws RecognitionException { 274 JavadocContext _localctx = new JavadocContext(_ctx, getState()); 275 enterRule(_localctx, 0, RULE_javadoc); 276 int _la; 277 try { 278 int _alt; 279 enterOuterAlt(_localctx, 1); 280 { 281 setState(160); 282 _errHandler.sync(this); 283 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 284 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 285 if ( _alt==1 ) { 286 { 287 setState(158); 288 _errHandler.sync(this); 289 switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { 290 case 1: 291 { 292 setState(150); 293 htmlElement(); 294 } 295 break; 296 case 2: 297 { 298 { 299 setState(151); 300 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 301 setState(152); 302 match(LEADING_ASTERISK); 303 } 304 } 305 break; 306 case 3: 307 { 308 setState(153); 309 htmlComment(); 310 } 311 break; 312 case 4: 313 { 314 setState(154); 315 match(CDATA); 316 } 317 break; 318 case 5: 319 { 320 setState(155); 321 match(NEWLINE); 322 } 323 break; 324 case 6: 325 { 326 setState(156); 327 text(); 328 } 329 break; 330 case 7: 331 { 332 setState(157); 333 javadocInlineTag(); 334 } 335 break; 336 } 337 } 338 } 339 setState(162); 340 _errHandler.sync(this); 341 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 342 } 343 setState(175); 344 _errHandler.sync(this); 345 _la = _input.LA(1); 346 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)) { 347 { 348 { 349 setState(164); 350 _errHandler.sync(this); 351 _la = _input.LA(1); 352 if (_la==LEADING_ASTERISK) { 353 { 354 setState(163); 355 match(LEADING_ASTERISK); 356 } 357 } 358 359 setState(169); 360 _errHandler.sync(this); 361 _la = _input.LA(1); 362 while (_la==WS) { 363 { 364 { 365 setState(166); 366 match(WS); 367 } 368 } 369 setState(171); 370 _errHandler.sync(this); 371 _la = _input.LA(1); 372 } 373 setState(172); 374 javadocTag(); 375 } 376 } 377 setState(177); 378 _errHandler.sync(this); 379 _la = _input.LA(1); 380 } 381 setState(178); 382 match(EOF); 383 } 384 } 385 catch (RecognitionException re) { 386 _localctx.exception = re; 387 _errHandler.reportError(this, re); 388 _errHandler.recover(this, re); 389 } 390 finally { 391 exitRule(); 392 } 393 return _localctx; 394 } 395 396 public static class HtmlElementContext extends ParserRuleContext { 397 public HtmlTagContext htmlTag() { 398 return getRuleContext(HtmlTagContext.class,0); 399 } 400 public SingletonElementContext singletonElement() { 401 return getRuleContext(SingletonElementContext.class,0); 402 } 403 public ParagraphContext paragraph() { 404 return getRuleContext(ParagraphContext.class,0); 405 } 406 public LiContext li() { 407 return getRuleContext(LiContext.class,0); 408 } 409 public TrContext tr() { 410 return getRuleContext(TrContext.class,0); 411 } 412 public TdContext td() { 413 return getRuleContext(TdContext.class,0); 414 } 415 public ThContext th() { 416 return getRuleContext(ThContext.class,0); 417 } 418 public BodyContext body() { 419 return getRuleContext(BodyContext.class,0); 420 } 421 public ColgroupContext colgroup() { 422 return getRuleContext(ColgroupContext.class,0); 423 } 424 public DdContext dd() { 425 return getRuleContext(DdContext.class,0); 426 } 427 public DtContext dt() { 428 return getRuleContext(DtContext.class,0); 429 } 430 public HeadContext head() { 431 return getRuleContext(HeadContext.class,0); 432 } 433 public HtmlContext html() { 434 return getRuleContext(HtmlContext.class,0); 435 } 436 public OptionContext option() { 437 return getRuleContext(OptionContext.class,0); 438 } 439 public TbodyContext tbody() { 440 return getRuleContext(TbodyContext.class,0); 441 } 442 public TheadContext thead() { 443 return getRuleContext(TheadContext.class,0); 444 } 445 public TfootContext tfoot() { 446 return getRuleContext(TfootContext.class,0); 447 } 448 public PTagOpenContext pTagOpen() { 449 return getRuleContext(PTagOpenContext.class,0); 450 } 451 public LiTagOpenContext liTagOpen() { 452 return getRuleContext(LiTagOpenContext.class,0); 453 } 454 public TrTagOpenContext trTagOpen() { 455 return getRuleContext(TrTagOpenContext.class,0); 456 } 457 public TdTagOpenContext tdTagOpen() { 458 return getRuleContext(TdTagOpenContext.class,0); 459 } 460 public ThTagOpenContext thTagOpen() { 461 return getRuleContext(ThTagOpenContext.class,0); 462 } 463 public BodyTagOpenContext bodyTagOpen() { 464 return getRuleContext(BodyTagOpenContext.class,0); 465 } 466 public ColgroupTagOpenContext colgroupTagOpen() { 467 return getRuleContext(ColgroupTagOpenContext.class,0); 468 } 469 public DdTagOpenContext ddTagOpen() { 470 return getRuleContext(DdTagOpenContext.class,0); 471 } 472 public DtTagOpenContext dtTagOpen() { 473 return getRuleContext(DtTagOpenContext.class,0); 474 } 475 public HeadTagOpenContext headTagOpen() { 476 return getRuleContext(HeadTagOpenContext.class,0); 477 } 478 public HtmlTagOpenContext htmlTagOpen() { 479 return getRuleContext(HtmlTagOpenContext.class,0); 480 } 481 public OptionTagOpenContext optionTagOpen() { 482 return getRuleContext(OptionTagOpenContext.class,0); 483 } 484 public TbodyTagOpenContext tbodyTagOpen() { 485 return getRuleContext(TbodyTagOpenContext.class,0); 486 } 487 public TheadTagOpenContext theadTagOpen() { 488 return getRuleContext(TheadTagOpenContext.class,0); 489 } 490 public TfootTagOpenContext tfootTagOpen() { 491 return getRuleContext(TfootTagOpenContext.class,0); 492 } 493 public PTagCloseContext pTagClose() { 494 return getRuleContext(PTagCloseContext.class,0); 495 } 496 public LiTagCloseContext liTagClose() { 497 return getRuleContext(LiTagCloseContext.class,0); 498 } 499 public TrTagCloseContext trTagClose() { 500 return getRuleContext(TrTagCloseContext.class,0); 501 } 502 public TdTagCloseContext tdTagClose() { 503 return getRuleContext(TdTagCloseContext.class,0); 504 } 505 public ThTagCloseContext thTagClose() { 506 return getRuleContext(ThTagCloseContext.class,0); 507 } 508 public BodyTagCloseContext bodyTagClose() { 509 return getRuleContext(BodyTagCloseContext.class,0); 510 } 511 public ColgroupTagCloseContext colgroupTagClose() { 512 return getRuleContext(ColgroupTagCloseContext.class,0); 513 } 514 public DdTagCloseContext ddTagClose() { 515 return getRuleContext(DdTagCloseContext.class,0); 516 } 517 public DtTagCloseContext dtTagClose() { 518 return getRuleContext(DtTagCloseContext.class,0); 519 } 520 public HeadTagCloseContext headTagClose() { 521 return getRuleContext(HeadTagCloseContext.class,0); 522 } 523 public HtmlTagCloseContext htmlTagClose() { 524 return getRuleContext(HtmlTagCloseContext.class,0); 525 } 526 public OptionTagCloseContext optionTagClose() { 527 return getRuleContext(OptionTagCloseContext.class,0); 528 } 529 public TbodyTagCloseContext tbodyTagClose() { 530 return getRuleContext(TbodyTagCloseContext.class,0); 531 } 532 public TheadTagCloseContext theadTagClose() { 533 return getRuleContext(TheadTagCloseContext.class,0); 534 } 535 public TfootTagCloseContext tfootTagClose() { 536 return getRuleContext(TfootTagCloseContext.class,0); 537 } 538 public HtmlElementContext(ParserRuleContext parent, int invokingState) { 539 super(parent, invokingState); 540 } 541 @Override public int getRuleIndex() { return RULE_htmlElement; } 542 @Override 543 public void enterRule(ParseTreeListener listener) { 544 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElement(this); 545 } 546 @Override 547 public void exitRule(ParseTreeListener listener) { 548 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElement(this); 549 } 550 @Override 551 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 552 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElement(this); 553 else return visitor.visitChildren(this); 554 } 555 } 556 557 public final HtmlElementContext htmlElement() throws RecognitionException { 558 HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState()); 559 enterRule(_localctx, 2, RULE_htmlElement); 560 try { 561 setState(227); 562 _errHandler.sync(this); 563 switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { 564 case 1: 565 enterOuterAlt(_localctx, 1); 566 { 567 setState(180); 568 htmlTag(); 569 } 570 break; 571 case 2: 572 enterOuterAlt(_localctx, 2); 573 { 574 setState(181); 575 singletonElement(); 576 } 577 break; 578 case 3: 579 enterOuterAlt(_localctx, 3); 580 { 581 setState(182); 582 paragraph(); 583 } 584 break; 585 case 4: 586 enterOuterAlt(_localctx, 4); 587 { 588 setState(183); 589 li(); 590 } 591 break; 592 case 5: 593 enterOuterAlt(_localctx, 5); 594 { 595 setState(184); 596 tr(); 597 } 598 break; 599 case 6: 600 enterOuterAlt(_localctx, 6); 601 { 602 setState(185); 603 td(); 604 } 605 break; 606 case 7: 607 enterOuterAlt(_localctx, 7); 608 { 609 setState(186); 610 th(); 611 } 612 break; 613 case 8: 614 enterOuterAlt(_localctx, 8); 615 { 616 setState(187); 617 body(); 618 } 619 break; 620 case 9: 621 enterOuterAlt(_localctx, 9); 622 { 623 setState(188); 624 colgroup(); 625 } 626 break; 627 case 10: 628 enterOuterAlt(_localctx, 10); 629 { 630 setState(189); 631 dd(); 632 } 633 break; 634 case 11: 635 enterOuterAlt(_localctx, 11); 636 { 637 setState(190); 638 dt(); 639 } 640 break; 641 case 12: 642 enterOuterAlt(_localctx, 12); 643 { 644 setState(191); 645 head(); 646 } 647 break; 648 case 13: 649 enterOuterAlt(_localctx, 13); 650 { 651 setState(192); 652 html(); 653 } 654 break; 655 case 14: 656 enterOuterAlt(_localctx, 14); 657 { 658 setState(193); 659 option(); 660 } 661 break; 662 case 15: 663 enterOuterAlt(_localctx, 15); 664 { 665 setState(194); 666 tbody(); 667 } 668 break; 669 case 16: 670 enterOuterAlt(_localctx, 16); 671 { 672 setState(195); 673 thead(); 674 } 675 break; 676 case 17: 677 enterOuterAlt(_localctx, 17); 678 { 679 setState(196); 680 tfoot(); 681 } 682 break; 683 case 18: 684 enterOuterAlt(_localctx, 18); 685 { 686 setState(197); 687 pTagOpen(); 688 } 689 break; 690 case 19: 691 enterOuterAlt(_localctx, 19); 692 { 693 setState(198); 694 liTagOpen(); 695 } 696 break; 697 case 20: 698 enterOuterAlt(_localctx, 20); 699 { 700 setState(199); 701 trTagOpen(); 702 } 703 break; 704 case 21: 705 enterOuterAlt(_localctx, 21); 706 { 707 setState(200); 708 tdTagOpen(); 709 } 710 break; 711 case 22: 712 enterOuterAlt(_localctx, 22); 713 { 714 setState(201); 715 thTagOpen(); 716 } 717 break; 718 case 23: 719 enterOuterAlt(_localctx, 23); 720 { 721 setState(202); 722 bodyTagOpen(); 723 } 724 break; 725 case 24: 726 enterOuterAlt(_localctx, 24); 727 { 728 setState(203); 729 colgroupTagOpen(); 730 } 731 break; 732 case 25: 733 enterOuterAlt(_localctx, 25); 734 { 735 setState(204); 736 ddTagOpen(); 737 } 738 break; 739 case 26: 740 enterOuterAlt(_localctx, 26); 741 { 742 setState(205); 743 dtTagOpen(); 744 } 745 break; 746 case 27: 747 enterOuterAlt(_localctx, 27); 748 { 749 setState(206); 750 headTagOpen(); 751 } 752 break; 753 case 28: 754 enterOuterAlt(_localctx, 28); 755 { 756 setState(207); 757 htmlTagOpen(); 758 } 759 break; 760 case 29: 761 enterOuterAlt(_localctx, 29); 762 { 763 setState(208); 764 optionTagOpen(); 765 } 766 break; 767 case 30: 768 enterOuterAlt(_localctx, 30); 769 { 770 setState(209); 771 tbodyTagOpen(); 772 } 773 break; 774 case 31: 775 enterOuterAlt(_localctx, 31); 776 { 777 setState(210); 778 theadTagOpen(); 779 } 780 break; 781 case 32: 782 enterOuterAlt(_localctx, 32); 783 { 784 setState(211); 785 tfootTagOpen(); 786 } 787 break; 788 case 33: 789 enterOuterAlt(_localctx, 33); 790 { 791 setState(212); 792 pTagClose(); 793 } 794 break; 795 case 34: 796 enterOuterAlt(_localctx, 34); 797 { 798 setState(213); 799 liTagClose(); 800 } 801 break; 802 case 35: 803 enterOuterAlt(_localctx, 35); 804 { 805 setState(214); 806 trTagClose(); 807 } 808 break; 809 case 36: 810 enterOuterAlt(_localctx, 36); 811 { 812 setState(215); 813 tdTagClose(); 814 } 815 break; 816 case 37: 817 enterOuterAlt(_localctx, 37); 818 { 819 setState(216); 820 thTagClose(); 821 } 822 break; 823 case 38: 824 enterOuterAlt(_localctx, 38); 825 { 826 setState(217); 827 bodyTagClose(); 828 } 829 break; 830 case 39: 831 enterOuterAlt(_localctx, 39); 832 { 833 setState(218); 834 colgroupTagClose(); 835 } 836 break; 837 case 40: 838 enterOuterAlt(_localctx, 40); 839 { 840 setState(219); 841 ddTagClose(); 842 } 843 break; 844 case 41: 845 enterOuterAlt(_localctx, 41); 846 { 847 setState(220); 848 dtTagClose(); 849 } 850 break; 851 case 42: 852 enterOuterAlt(_localctx, 42); 853 { 854 setState(221); 855 headTagClose(); 856 } 857 break; 858 case 43: 859 enterOuterAlt(_localctx, 43); 860 { 861 setState(222); 862 htmlTagClose(); 863 } 864 break; 865 case 44: 866 enterOuterAlt(_localctx, 44); 867 { 868 setState(223); 869 optionTagClose(); 870 } 871 break; 872 case 45: 873 enterOuterAlt(_localctx, 45); 874 { 875 setState(224); 876 tbodyTagClose(); 877 } 878 break; 879 case 46: 880 enterOuterAlt(_localctx, 46); 881 { 882 setState(225); 883 theadTagClose(); 884 } 885 break; 886 case 47: 887 enterOuterAlt(_localctx, 47); 888 { 889 setState(226); 890 tfootTagClose(); 891 } 892 break; 893 } 894 } 895 catch (RecognitionException re) { 896 _localctx.exception = re; 897 _errHandler.reportError(this, re); 898 _errHandler.recover(this, re); 899 } 900 finally { 901 exitRule(); 902 } 903 return _localctx; 904 } 905 906 public static class HtmlElementOpenContext extends ParserRuleContext { 907 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 908 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 909 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 910 public List<AttributeContext> attribute() { 911 return getRuleContexts(AttributeContext.class); 912 } 913 public AttributeContext attribute(int i) { 914 return getRuleContext(AttributeContext.class,i); 915 } 916 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 917 public TerminalNode NEWLINE(int i) { 918 return getToken(JavadocParser.NEWLINE, i); 919 } 920 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 921 public TerminalNode LEADING_ASTERISK(int i) { 922 return getToken(JavadocParser.LEADING_ASTERISK, i); 923 } 924 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 925 public TerminalNode WS(int i) { 926 return getToken(JavadocParser.WS, i); 927 } 928 public HtmlElementOpenContext(ParserRuleContext parent, int invokingState) { 929 super(parent, invokingState); 930 } 931 @Override public int getRuleIndex() { return RULE_htmlElementOpen; } 932 @Override 933 public void enterRule(ParseTreeListener listener) { 934 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementOpen(this); 935 } 936 @Override 937 public void exitRule(ParseTreeListener listener) { 938 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementOpen(this); 939 } 940 @Override 941 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 942 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementOpen(this); 943 else return visitor.visitChildren(this); 944 } 945 } 946 947 public final HtmlElementOpenContext htmlElementOpen() throws RecognitionException { 948 HtmlElementOpenContext _localctx = new HtmlElementOpenContext(_ctx, getState()); 949 enterRule(_localctx, 4, RULE_htmlElementOpen); 950 int _la; 951 try { 952 enterOuterAlt(_localctx, 1); 953 { 954 setState(229); 955 match(OPEN); 956 setState(230); 957 match(HTML_TAG_NAME); 958 setState(237); 959 _errHandler.sync(this); 960 _la = _input.LA(1); 961 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 962 { 963 setState(235); 964 _errHandler.sync(this); 965 switch (_input.LA(1)) { 966 case HTML_TAG_NAME: 967 { 968 setState(231); 969 attribute(); 970 } 971 break; 972 case NEWLINE: 973 { 974 setState(232); 975 match(NEWLINE); 976 } 977 break; 978 case LEADING_ASTERISK: 979 { 980 setState(233); 981 match(LEADING_ASTERISK); 982 } 983 break; 984 case WS: 985 { 986 setState(234); 987 match(WS); 988 } 989 break; 990 default: 991 throw new NoViableAltException(this); 992 } 993 } 994 setState(239); 995 _errHandler.sync(this); 996 _la = _input.LA(1); 997 } 998 setState(240); 999 match(CLOSE); 1000 } 1001 } 1002 catch (RecognitionException re) { 1003 _localctx.exception = re; 1004 _errHandler.reportError(this, re); 1005 _errHandler.recover(this, re); 1006 } 1007 finally { 1008 exitRule(); 1009 } 1010 return _localctx; 1011 } 1012 1013 public static class HtmlElementCloseContext extends ParserRuleContext { 1014 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1015 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1016 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 1017 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1018 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1019 public TerminalNode NEWLINE(int i) { 1020 return getToken(JavadocParser.NEWLINE, i); 1021 } 1022 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1023 public TerminalNode LEADING_ASTERISK(int i) { 1024 return getToken(JavadocParser.LEADING_ASTERISK, i); 1025 } 1026 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1027 public TerminalNode WS(int i) { 1028 return getToken(JavadocParser.WS, i); 1029 } 1030 public HtmlElementCloseContext(ParserRuleContext parent, int invokingState) { 1031 super(parent, invokingState); 1032 } 1033 @Override public int getRuleIndex() { return RULE_htmlElementClose; } 1034 @Override 1035 public void enterRule(ParseTreeListener listener) { 1036 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementClose(this); 1037 } 1038 @Override 1039 public void exitRule(ParseTreeListener listener) { 1040 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementClose(this); 1041 } 1042 @Override 1043 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1044 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementClose(this); 1045 else return visitor.visitChildren(this); 1046 } 1047 } 1048 1049 public final HtmlElementCloseContext htmlElementClose() throws RecognitionException { 1050 HtmlElementCloseContext _localctx = new HtmlElementCloseContext(_ctx, getState()); 1051 enterRule(_localctx, 6, RULE_htmlElementClose); 1052 int _la; 1053 try { 1054 enterOuterAlt(_localctx, 1); 1055 { 1056 setState(242); 1057 match(OPEN); 1058 setState(243); 1059 match(SLASH); 1060 setState(244); 1061 match(HTML_TAG_NAME); 1062 setState(248); 1063 _errHandler.sync(this); 1064 _la = _input.LA(1); 1065 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1066 { 1067 { 1068 setState(245); 1069 _la = _input.LA(1); 1070 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1071 _errHandler.recoverInline(this); 1072 } 1073 else { 1074 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1075 _errHandler.reportMatch(this); 1076 consume(); 1077 } 1078 } 1079 } 1080 setState(250); 1081 _errHandler.sync(this); 1082 _la = _input.LA(1); 1083 } 1084 setState(251); 1085 match(CLOSE); 1086 } 1087 } 1088 catch (RecognitionException re) { 1089 _localctx.exception = re; 1090 _errHandler.reportError(this, re); 1091 _errHandler.recover(this, re); 1092 } 1093 finally { 1094 exitRule(); 1095 } 1096 return _localctx; 1097 } 1098 1099 public static class AttributeContext extends ParserRuleContext { 1100 public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); } 1101 public TerminalNode HTML_TAG_NAME(int i) { 1102 return getToken(JavadocParser.HTML_TAG_NAME, i); 1103 } 1104 public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); } 1105 public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); } 1106 public TextContext text() { 1107 return getRuleContext(TextContext.class,0); 1108 } 1109 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1110 public TerminalNode NEWLINE(int i) { 1111 return getToken(JavadocParser.NEWLINE, i); 1112 } 1113 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1114 public TerminalNode LEADING_ASTERISK(int i) { 1115 return getToken(JavadocParser.LEADING_ASTERISK, i); 1116 } 1117 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1118 public TerminalNode WS(int i) { 1119 return getToken(JavadocParser.WS, i); 1120 } 1121 public AttributeContext(ParserRuleContext parent, int invokingState) { 1122 super(parent, invokingState); 1123 } 1124 @Override public int getRuleIndex() { return RULE_attribute; } 1125 @Override 1126 public void enterRule(ParseTreeListener listener) { 1127 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAttribute(this); 1128 } 1129 @Override 1130 public void exitRule(ParseTreeListener listener) { 1131 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAttribute(this); 1132 } 1133 @Override 1134 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1135 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAttribute(this); 1136 else return visitor.visitChildren(this); 1137 } 1138 } 1139 1140 public final AttributeContext attribute() throws RecognitionException { 1141 AttributeContext _localctx = new AttributeContext(_ctx, getState()); 1142 enterRule(_localctx, 8, RULE_attribute); 1143 int _la; 1144 try { 1145 int _alt; 1146 enterOuterAlt(_localctx, 1); 1147 { 1148 setState(253); 1149 match(HTML_TAG_NAME); 1150 setState(257); 1151 _errHandler.sync(this); 1152 _la = _input.LA(1); 1153 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1154 { 1155 { 1156 setState(254); 1157 _la = _input.LA(1); 1158 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1159 _errHandler.recoverInline(this); 1160 } 1161 else { 1162 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1163 _errHandler.reportMatch(this); 1164 consume(); 1165 } 1166 } 1167 } 1168 setState(259); 1169 _errHandler.sync(this); 1170 _la = _input.LA(1); 1171 } 1172 setState(260); 1173 match(EQUALS); 1174 setState(264); 1175 _errHandler.sync(this); 1176 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1177 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1178 if ( _alt==1 ) { 1179 { 1180 { 1181 setState(261); 1182 _la = _input.LA(1); 1183 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1184 _errHandler.recoverInline(this); 1185 } 1186 else { 1187 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1188 _errHandler.reportMatch(this); 1189 consume(); 1190 } 1191 } 1192 } 1193 } 1194 setState(266); 1195 _errHandler.sync(this); 1196 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1197 } 1198 setState(270); 1199 _errHandler.sync(this); 1200 switch (_input.LA(1)) { 1201 case ATTR_VALUE: 1202 { 1203 setState(267); 1204 match(ATTR_VALUE); 1205 } 1206 break; 1207 case WS: 1208 case CHAR: 1209 { 1210 setState(268); 1211 text(); 1212 } 1213 break; 1214 case HTML_TAG_NAME: 1215 { 1216 setState(269); 1217 match(HTML_TAG_NAME); 1218 } 1219 break; 1220 default: 1221 throw new NoViableAltException(this); 1222 } 1223 } 1224 } 1225 catch (RecognitionException re) { 1226 _localctx.exception = re; 1227 _errHandler.reportError(this, re); 1228 _errHandler.recover(this, re); 1229 } 1230 finally { 1231 exitRule(); 1232 } 1233 return _localctx; 1234 } 1235 1236 public static class HtmlTagContext extends ParserRuleContext { 1237 public HtmlElementOpenContext htmlElementOpen; 1238 public HtmlElementOpenContext htmlElementOpen() { 1239 return getRuleContext(HtmlElementOpenContext.class,0); 1240 } 1241 public HtmlElementCloseContext htmlElementClose() { 1242 return getRuleContext(HtmlElementCloseContext.class,0); 1243 } 1244 public List<HtmlElementContext> htmlElement() { 1245 return getRuleContexts(HtmlElementContext.class); 1246 } 1247 public HtmlElementContext htmlElement(int i) { 1248 return getRuleContext(HtmlElementContext.class,i); 1249 } 1250 public List<HtmlCommentContext> htmlComment() { 1251 return getRuleContexts(HtmlCommentContext.class); 1252 } 1253 public HtmlCommentContext htmlComment(int i) { 1254 return getRuleContext(HtmlCommentContext.class,i); 1255 } 1256 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1257 public TerminalNode CDATA(int i) { 1258 return getToken(JavadocParser.CDATA, i); 1259 } 1260 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1261 public TerminalNode NEWLINE(int i) { 1262 return getToken(JavadocParser.NEWLINE, i); 1263 } 1264 public List<TextContext> text() { 1265 return getRuleContexts(TextContext.class); 1266 } 1267 public TextContext text(int i) { 1268 return getRuleContext(TextContext.class,i); 1269 } 1270 public List<JavadocInlineTagContext> javadocInlineTag() { 1271 return getRuleContexts(JavadocInlineTagContext.class); 1272 } 1273 public JavadocInlineTagContext javadocInlineTag(int i) { 1274 return getRuleContext(JavadocInlineTagContext.class,i); 1275 } 1276 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1277 public TerminalNode LEADING_ASTERISK(int i) { 1278 return getToken(JavadocParser.LEADING_ASTERISK, i); 1279 } 1280 public HtmlTagContext(ParserRuleContext parent, int invokingState) { 1281 super(parent, invokingState); 1282 } 1283 @Override public int getRuleIndex() { return RULE_htmlTag; } 1284 @Override 1285 public void enterRule(ParseTreeListener listener) { 1286 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTag(this); 1287 } 1288 @Override 1289 public void exitRule(ParseTreeListener listener) { 1290 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTag(this); 1291 } 1292 @Override 1293 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1294 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTag(this); 1295 else return visitor.visitChildren(this); 1296 } 1297 } 1298 1299 public final HtmlTagContext htmlTag() throws RecognitionException { 1300 HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState()); 1301 enterRule(_localctx, 10, RULE_htmlTag); 1302 try { 1303 int _alt; 1304 setState(304); 1305 _errHandler.sync(this); 1306 switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { 1307 case 1: 1308 enterOuterAlt(_localctx, 1); 1309 { 1310 setState(272); 1311 htmlElementOpen(); 1312 setState(283); 1313 _errHandler.sync(this); 1314 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1315 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1316 if ( _alt==1 ) { 1317 { 1318 setState(281); 1319 _errHandler.sync(this); 1320 switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { 1321 case 1: 1322 { 1323 setState(273); 1324 htmlElement(); 1325 } 1326 break; 1327 case 2: 1328 { 1329 { 1330 setState(274); 1331 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1332 setState(275); 1333 match(LEADING_ASTERISK); 1334 } 1335 } 1336 break; 1337 case 3: 1338 { 1339 setState(276); 1340 htmlComment(); 1341 } 1342 break; 1343 case 4: 1344 { 1345 setState(277); 1346 match(CDATA); 1347 } 1348 break; 1349 case 5: 1350 { 1351 setState(278); 1352 match(NEWLINE); 1353 } 1354 break; 1355 case 6: 1356 { 1357 setState(279); 1358 text(); 1359 } 1360 break; 1361 case 7: 1362 { 1363 setState(280); 1364 javadocInlineTag(); 1365 } 1366 break; 1367 } 1368 } 1369 } 1370 setState(285); 1371 _errHandler.sync(this); 1372 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1373 } 1374 setState(286); 1375 htmlElementClose(); 1376 } 1377 break; 1378 case 2: 1379 enterOuterAlt(_localctx, 2); 1380 { 1381 setState(288); 1382 ((HtmlTagContext)_localctx).htmlElementOpen = htmlElementOpen(); 1383 setState(299); 1384 _errHandler.sync(this); 1385 _alt = getInterpreter().adaptivePredict(_input,15,_ctx); 1386 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1387 if ( _alt==1 ) { 1388 { 1389 setState(297); 1390 _errHandler.sync(this); 1391 switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { 1392 case 1: 1393 { 1394 setState(289); 1395 htmlElement(); 1396 } 1397 break; 1398 case 2: 1399 { 1400 { 1401 setState(290); 1402 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1403 setState(291); 1404 match(LEADING_ASTERISK); 1405 } 1406 } 1407 break; 1408 case 3: 1409 { 1410 setState(292); 1411 htmlComment(); 1412 } 1413 break; 1414 case 4: 1415 { 1416 setState(293); 1417 match(CDATA); 1418 } 1419 break; 1420 case 5: 1421 { 1422 setState(294); 1423 match(NEWLINE); 1424 } 1425 break; 1426 case 6: 1427 { 1428 setState(295); 1429 text(); 1430 } 1431 break; 1432 case 7: 1433 { 1434 setState(296); 1435 javadocInlineTag(); 1436 } 1437 break; 1438 } 1439 } 1440 } 1441 setState(301); 1442 _errHandler.sync(this); 1443 _alt = getInterpreter().adaptivePredict(_input,15,_ctx); 1444 } 1445 notifyErrorListeners(((HtmlTagContext)_localctx).htmlElementOpen.getToken(HTML_TAG_NAME, 0).getSymbol() 1446 , "javadoc.missed.html.close", null); 1447 } 1448 break; 1449 } 1450 } 1451 catch (RecognitionException re) { 1452 _localctx.exception = re; 1453 _errHandler.reportError(this, re); 1454 _errHandler.recover(this, re); 1455 } 1456 finally { 1457 exitRule(); 1458 } 1459 return _localctx; 1460 } 1461 1462 public static class PTagOpenContext extends ParserRuleContext { 1463 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1464 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1465 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1466 public List<AttributeContext> attribute() { 1467 return getRuleContexts(AttributeContext.class); 1468 } 1469 public AttributeContext attribute(int i) { 1470 return getRuleContext(AttributeContext.class,i); 1471 } 1472 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1473 public TerminalNode NEWLINE(int i) { 1474 return getToken(JavadocParser.NEWLINE, i); 1475 } 1476 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1477 public TerminalNode LEADING_ASTERISK(int i) { 1478 return getToken(JavadocParser.LEADING_ASTERISK, i); 1479 } 1480 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1481 public TerminalNode WS(int i) { 1482 return getToken(JavadocParser.WS, i); 1483 } 1484 public PTagOpenContext(ParserRuleContext parent, int invokingState) { 1485 super(parent, invokingState); 1486 } 1487 @Override public int getRuleIndex() { return RULE_pTagOpen; } 1488 @Override 1489 public void enterRule(ParseTreeListener listener) { 1490 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagOpen(this); 1491 } 1492 @Override 1493 public void exitRule(ParseTreeListener listener) { 1494 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagOpen(this); 1495 } 1496 @Override 1497 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1498 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagOpen(this); 1499 else return visitor.visitChildren(this); 1500 } 1501 } 1502 1503 public final PTagOpenContext pTagOpen() throws RecognitionException { 1504 PTagOpenContext _localctx = new PTagOpenContext(_ctx, getState()); 1505 enterRule(_localctx, 12, RULE_pTagOpen); 1506 int _la; 1507 try { 1508 enterOuterAlt(_localctx, 1); 1509 { 1510 setState(306); 1511 match(OPEN); 1512 setState(307); 1513 match(P_HTML_TAG_NAME); 1514 setState(314); 1515 _errHandler.sync(this); 1516 _la = _input.LA(1); 1517 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 1518 { 1519 setState(312); 1520 _errHandler.sync(this); 1521 switch (_input.LA(1)) { 1522 case HTML_TAG_NAME: 1523 { 1524 setState(308); 1525 attribute(); 1526 } 1527 break; 1528 case NEWLINE: 1529 { 1530 setState(309); 1531 match(NEWLINE); 1532 } 1533 break; 1534 case LEADING_ASTERISK: 1535 { 1536 setState(310); 1537 match(LEADING_ASTERISK); 1538 } 1539 break; 1540 case WS: 1541 { 1542 setState(311); 1543 match(WS); 1544 } 1545 break; 1546 default: 1547 throw new NoViableAltException(this); 1548 } 1549 } 1550 setState(316); 1551 _errHandler.sync(this); 1552 _la = _input.LA(1); 1553 } 1554 setState(317); 1555 match(CLOSE); 1556 } 1557 } 1558 catch (RecognitionException re) { 1559 _localctx.exception = re; 1560 _errHandler.reportError(this, re); 1561 _errHandler.recover(this, re); 1562 } 1563 finally { 1564 exitRule(); 1565 } 1566 return _localctx; 1567 } 1568 1569 public static class PTagCloseContext extends ParserRuleContext { 1570 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1571 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1572 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1573 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1574 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1575 public TerminalNode NEWLINE(int i) { 1576 return getToken(JavadocParser.NEWLINE, i); 1577 } 1578 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1579 public TerminalNode LEADING_ASTERISK(int i) { 1580 return getToken(JavadocParser.LEADING_ASTERISK, i); 1581 } 1582 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1583 public TerminalNode WS(int i) { 1584 return getToken(JavadocParser.WS, i); 1585 } 1586 public PTagCloseContext(ParserRuleContext parent, int invokingState) { 1587 super(parent, invokingState); 1588 } 1589 @Override public int getRuleIndex() { return RULE_pTagClose; } 1590 @Override 1591 public void enterRule(ParseTreeListener listener) { 1592 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagClose(this); 1593 } 1594 @Override 1595 public void exitRule(ParseTreeListener listener) { 1596 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagClose(this); 1597 } 1598 @Override 1599 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1600 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagClose(this); 1601 else return visitor.visitChildren(this); 1602 } 1603 } 1604 1605 public final PTagCloseContext pTagClose() throws RecognitionException { 1606 PTagCloseContext _localctx = new PTagCloseContext(_ctx, getState()); 1607 enterRule(_localctx, 14, RULE_pTagClose); 1608 int _la; 1609 try { 1610 enterOuterAlt(_localctx, 1); 1611 { 1612 setState(319); 1613 match(OPEN); 1614 setState(320); 1615 match(SLASH); 1616 setState(321); 1617 match(P_HTML_TAG_NAME); 1618 setState(325); 1619 _errHandler.sync(this); 1620 _la = _input.LA(1); 1621 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1622 { 1623 { 1624 setState(322); 1625 _la = _input.LA(1); 1626 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1627 _errHandler.recoverInline(this); 1628 } 1629 else { 1630 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1631 _errHandler.reportMatch(this); 1632 consume(); 1633 } 1634 } 1635 } 1636 setState(327); 1637 _errHandler.sync(this); 1638 _la = _input.LA(1); 1639 } 1640 setState(328); 1641 match(CLOSE); 1642 } 1643 } 1644 catch (RecognitionException re) { 1645 _localctx.exception = re; 1646 _errHandler.reportError(this, re); 1647 _errHandler.recover(this, re); 1648 } 1649 finally { 1650 exitRule(); 1651 } 1652 return _localctx; 1653 } 1654 1655 public static class ParagraphContext extends ParserRuleContext { 1656 public PTagOpenContext pTagOpen() { 1657 return getRuleContext(PTagOpenContext.class,0); 1658 } 1659 public PTagCloseContext pTagClose() { 1660 return getRuleContext(PTagCloseContext.class,0); 1661 } 1662 public List<HtmlTagContext> htmlTag() { 1663 return getRuleContexts(HtmlTagContext.class); 1664 } 1665 public HtmlTagContext htmlTag(int i) { 1666 return getRuleContext(HtmlTagContext.class,i); 1667 } 1668 public List<SingletonTagContext> singletonTag() { 1669 return getRuleContexts(SingletonTagContext.class); 1670 } 1671 public SingletonTagContext singletonTag(int i) { 1672 return getRuleContext(SingletonTagContext.class,i); 1673 } 1674 public List<LiContext> li() { 1675 return getRuleContexts(LiContext.class); 1676 } 1677 public LiContext li(int i) { 1678 return getRuleContext(LiContext.class,i); 1679 } 1680 public List<TrContext> tr() { 1681 return getRuleContexts(TrContext.class); 1682 } 1683 public TrContext tr(int i) { 1684 return getRuleContext(TrContext.class,i); 1685 } 1686 public List<TdContext> td() { 1687 return getRuleContexts(TdContext.class); 1688 } 1689 public TdContext td(int i) { 1690 return getRuleContext(TdContext.class,i); 1691 } 1692 public List<ThContext> th() { 1693 return getRuleContexts(ThContext.class); 1694 } 1695 public ThContext th(int i) { 1696 return getRuleContext(ThContext.class,i); 1697 } 1698 public List<BodyContext> body() { 1699 return getRuleContexts(BodyContext.class); 1700 } 1701 public BodyContext body(int i) { 1702 return getRuleContext(BodyContext.class,i); 1703 } 1704 public List<ColgroupContext> colgroup() { 1705 return getRuleContexts(ColgroupContext.class); 1706 } 1707 public ColgroupContext colgroup(int i) { 1708 return getRuleContext(ColgroupContext.class,i); 1709 } 1710 public List<DdContext> dd() { 1711 return getRuleContexts(DdContext.class); 1712 } 1713 public DdContext dd(int i) { 1714 return getRuleContext(DdContext.class,i); 1715 } 1716 public List<DtContext> dt() { 1717 return getRuleContexts(DtContext.class); 1718 } 1719 public DtContext dt(int i) { 1720 return getRuleContext(DtContext.class,i); 1721 } 1722 public List<HeadContext> head() { 1723 return getRuleContexts(HeadContext.class); 1724 } 1725 public HeadContext head(int i) { 1726 return getRuleContext(HeadContext.class,i); 1727 } 1728 public List<HtmlContext> html() { 1729 return getRuleContexts(HtmlContext.class); 1730 } 1731 public HtmlContext html(int i) { 1732 return getRuleContext(HtmlContext.class,i); 1733 } 1734 public List<OptionContext> option() { 1735 return getRuleContexts(OptionContext.class); 1736 } 1737 public OptionContext option(int i) { 1738 return getRuleContext(OptionContext.class,i); 1739 } 1740 public List<TbodyContext> tbody() { 1741 return getRuleContexts(TbodyContext.class); 1742 } 1743 public TbodyContext tbody(int i) { 1744 return getRuleContext(TbodyContext.class,i); 1745 } 1746 public List<TheadContext> thead() { 1747 return getRuleContexts(TheadContext.class); 1748 } 1749 public TheadContext thead(int i) { 1750 return getRuleContext(TheadContext.class,i); 1751 } 1752 public List<TfootContext> tfoot() { 1753 return getRuleContexts(TfootContext.class); 1754 } 1755 public TfootContext tfoot(int i) { 1756 return getRuleContext(TfootContext.class,i); 1757 } 1758 public List<LiTagOpenContext> liTagOpen() { 1759 return getRuleContexts(LiTagOpenContext.class); 1760 } 1761 public LiTagOpenContext liTagOpen(int i) { 1762 return getRuleContext(LiTagOpenContext.class,i); 1763 } 1764 public List<TrTagOpenContext> trTagOpen() { 1765 return getRuleContexts(TrTagOpenContext.class); 1766 } 1767 public TrTagOpenContext trTagOpen(int i) { 1768 return getRuleContext(TrTagOpenContext.class,i); 1769 } 1770 public List<TdTagOpenContext> tdTagOpen() { 1771 return getRuleContexts(TdTagOpenContext.class); 1772 } 1773 public TdTagOpenContext tdTagOpen(int i) { 1774 return getRuleContext(TdTagOpenContext.class,i); 1775 } 1776 public List<ThTagOpenContext> thTagOpen() { 1777 return getRuleContexts(ThTagOpenContext.class); 1778 } 1779 public ThTagOpenContext thTagOpen(int i) { 1780 return getRuleContext(ThTagOpenContext.class,i); 1781 } 1782 public List<BodyTagOpenContext> bodyTagOpen() { 1783 return getRuleContexts(BodyTagOpenContext.class); 1784 } 1785 public BodyTagOpenContext bodyTagOpen(int i) { 1786 return getRuleContext(BodyTagOpenContext.class,i); 1787 } 1788 public List<ColgroupTagOpenContext> colgroupTagOpen() { 1789 return getRuleContexts(ColgroupTagOpenContext.class); 1790 } 1791 public ColgroupTagOpenContext colgroupTagOpen(int i) { 1792 return getRuleContext(ColgroupTagOpenContext.class,i); 1793 } 1794 public List<DdTagOpenContext> ddTagOpen() { 1795 return getRuleContexts(DdTagOpenContext.class); 1796 } 1797 public DdTagOpenContext ddTagOpen(int i) { 1798 return getRuleContext(DdTagOpenContext.class,i); 1799 } 1800 public List<DtTagOpenContext> dtTagOpen() { 1801 return getRuleContexts(DtTagOpenContext.class); 1802 } 1803 public DtTagOpenContext dtTagOpen(int i) { 1804 return getRuleContext(DtTagOpenContext.class,i); 1805 } 1806 public List<HeadTagOpenContext> headTagOpen() { 1807 return getRuleContexts(HeadTagOpenContext.class); 1808 } 1809 public HeadTagOpenContext headTagOpen(int i) { 1810 return getRuleContext(HeadTagOpenContext.class,i); 1811 } 1812 public List<HtmlTagOpenContext> htmlTagOpen() { 1813 return getRuleContexts(HtmlTagOpenContext.class); 1814 } 1815 public HtmlTagOpenContext htmlTagOpen(int i) { 1816 return getRuleContext(HtmlTagOpenContext.class,i); 1817 } 1818 public List<OptionTagOpenContext> optionTagOpen() { 1819 return getRuleContexts(OptionTagOpenContext.class); 1820 } 1821 public OptionTagOpenContext optionTagOpen(int i) { 1822 return getRuleContext(OptionTagOpenContext.class,i); 1823 } 1824 public List<TbodyTagOpenContext> tbodyTagOpen() { 1825 return getRuleContexts(TbodyTagOpenContext.class); 1826 } 1827 public TbodyTagOpenContext tbodyTagOpen(int i) { 1828 return getRuleContext(TbodyTagOpenContext.class,i); 1829 } 1830 public List<TheadTagOpenContext> theadTagOpen() { 1831 return getRuleContexts(TheadTagOpenContext.class); 1832 } 1833 public TheadTagOpenContext theadTagOpen(int i) { 1834 return getRuleContext(TheadTagOpenContext.class,i); 1835 } 1836 public List<TfootTagOpenContext> tfootTagOpen() { 1837 return getRuleContexts(TfootTagOpenContext.class); 1838 } 1839 public TfootTagOpenContext tfootTagOpen(int i) { 1840 return getRuleContext(TfootTagOpenContext.class,i); 1841 } 1842 public List<HtmlCommentContext> htmlComment() { 1843 return getRuleContexts(HtmlCommentContext.class); 1844 } 1845 public HtmlCommentContext htmlComment(int i) { 1846 return getRuleContext(HtmlCommentContext.class,i); 1847 } 1848 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1849 public TerminalNode CDATA(int i) { 1850 return getToken(JavadocParser.CDATA, i); 1851 } 1852 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1853 public TerminalNode NEWLINE(int i) { 1854 return getToken(JavadocParser.NEWLINE, i); 1855 } 1856 public List<TextContext> text() { 1857 return getRuleContexts(TextContext.class); 1858 } 1859 public TextContext text(int i) { 1860 return getRuleContext(TextContext.class,i); 1861 } 1862 public List<JavadocInlineTagContext> javadocInlineTag() { 1863 return getRuleContexts(JavadocInlineTagContext.class); 1864 } 1865 public JavadocInlineTagContext javadocInlineTag(int i) { 1866 return getRuleContext(JavadocInlineTagContext.class,i); 1867 } 1868 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1869 public TerminalNode LEADING_ASTERISK(int i) { 1870 return getToken(JavadocParser.LEADING_ASTERISK, i); 1871 } 1872 public ParagraphContext(ParserRuleContext parent, int invokingState) { 1873 super(parent, invokingState); 1874 } 1875 @Override public int getRuleIndex() { return RULE_paragraph; } 1876 @Override 1877 public void enterRule(ParseTreeListener listener) { 1878 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParagraph(this); 1879 } 1880 @Override 1881 public void exitRule(ParseTreeListener listener) { 1882 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParagraph(this); 1883 } 1884 @Override 1885 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1886 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParagraph(this); 1887 else return visitor.visitChildren(this); 1888 } 1889 } 1890 1891 public final ParagraphContext paragraph() throws RecognitionException { 1892 ParagraphContext _localctx = new ParagraphContext(_ctx, getState()); 1893 enterRule(_localctx, 16, RULE_paragraph); 1894 try { 1895 int _alt; 1896 enterOuterAlt(_localctx, 1); 1897 { 1898 setState(330); 1899 pTagOpen(); 1900 setState(370); 1901 _errHandler.sync(this); 1902 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 1903 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1904 if ( _alt==1 ) { 1905 { 1906 setState(368); 1907 _errHandler.sync(this); 1908 switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) { 1909 case 1: 1910 { 1911 setState(331); 1912 htmlTag(); 1913 } 1914 break; 1915 case 2: 1916 { 1917 setState(332); 1918 singletonTag(); 1919 } 1920 break; 1921 case 3: 1922 { 1923 setState(333); 1924 li(); 1925 } 1926 break; 1927 case 4: 1928 { 1929 setState(334); 1930 tr(); 1931 } 1932 break; 1933 case 5: 1934 { 1935 setState(335); 1936 td(); 1937 } 1938 break; 1939 case 6: 1940 { 1941 setState(336); 1942 th(); 1943 } 1944 break; 1945 case 7: 1946 { 1947 setState(337); 1948 body(); 1949 } 1950 break; 1951 case 8: 1952 { 1953 setState(338); 1954 colgroup(); 1955 } 1956 break; 1957 case 9: 1958 { 1959 setState(339); 1960 dd(); 1961 } 1962 break; 1963 case 10: 1964 { 1965 setState(340); 1966 dt(); 1967 } 1968 break; 1969 case 11: 1970 { 1971 setState(341); 1972 head(); 1973 } 1974 break; 1975 case 12: 1976 { 1977 setState(342); 1978 html(); 1979 } 1980 break; 1981 case 13: 1982 { 1983 setState(343); 1984 option(); 1985 } 1986 break; 1987 case 14: 1988 { 1989 setState(344); 1990 tbody(); 1991 } 1992 break; 1993 case 15: 1994 { 1995 setState(345); 1996 thead(); 1997 } 1998 break; 1999 case 16: 2000 { 2001 setState(346); 2002 tfoot(); 2003 } 2004 break; 2005 case 17: 2006 { 2007 setState(347); 2008 liTagOpen(); 2009 } 2010 break; 2011 case 18: 2012 { 2013 setState(348); 2014 trTagOpen(); 2015 } 2016 break; 2017 case 19: 2018 { 2019 setState(349); 2020 tdTagOpen(); 2021 } 2022 break; 2023 case 20: 2024 { 2025 setState(350); 2026 thTagOpen(); 2027 } 2028 break; 2029 case 21: 2030 { 2031 setState(351); 2032 bodyTagOpen(); 2033 } 2034 break; 2035 case 22: 2036 { 2037 setState(352); 2038 colgroupTagOpen(); 2039 } 2040 break; 2041 case 23: 2042 { 2043 setState(353); 2044 ddTagOpen(); 2045 } 2046 break; 2047 case 24: 2048 { 2049 setState(354); 2050 dtTagOpen(); 2051 } 2052 break; 2053 case 25: 2054 { 2055 setState(355); 2056 headTagOpen(); 2057 } 2058 break; 2059 case 26: 2060 { 2061 setState(356); 2062 htmlTagOpen(); 2063 } 2064 break; 2065 case 27: 2066 { 2067 setState(357); 2068 optionTagOpen(); 2069 } 2070 break; 2071 case 28: 2072 { 2073 setState(358); 2074 tbodyTagOpen(); 2075 } 2076 break; 2077 case 29: 2078 { 2079 setState(359); 2080 theadTagOpen(); 2081 } 2082 break; 2083 case 30: 2084 { 2085 setState(360); 2086 tfootTagOpen(); 2087 } 2088 break; 2089 case 31: 2090 { 2091 { 2092 setState(361); 2093 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2094 setState(362); 2095 match(LEADING_ASTERISK); 2096 } 2097 } 2098 break; 2099 case 32: 2100 { 2101 setState(363); 2102 htmlComment(); 2103 } 2104 break; 2105 case 33: 2106 { 2107 setState(364); 2108 match(CDATA); 2109 } 2110 break; 2111 case 34: 2112 { 2113 setState(365); 2114 match(NEWLINE); 2115 } 2116 break; 2117 case 35: 2118 { 2119 setState(366); 2120 text(); 2121 } 2122 break; 2123 case 36: 2124 { 2125 setState(367); 2126 javadocInlineTag(); 2127 } 2128 break; 2129 } 2130 } 2131 } 2132 setState(372); 2133 _errHandler.sync(this); 2134 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 2135 } 2136 setState(373); 2137 pTagClose(); 2138 } 2139 } 2140 catch (RecognitionException re) { 2141 _localctx.exception = re; 2142 _errHandler.reportError(this, re); 2143 _errHandler.recover(this, re); 2144 } 2145 finally { 2146 exitRule(); 2147 } 2148 return _localctx; 2149 } 2150 2151 public static class LiTagOpenContext extends ParserRuleContext { 2152 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2153 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2154 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2155 public List<AttributeContext> attribute() { 2156 return getRuleContexts(AttributeContext.class); 2157 } 2158 public AttributeContext attribute(int i) { 2159 return getRuleContext(AttributeContext.class,i); 2160 } 2161 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2162 public TerminalNode NEWLINE(int i) { 2163 return getToken(JavadocParser.NEWLINE, i); 2164 } 2165 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2166 public TerminalNode LEADING_ASTERISK(int i) { 2167 return getToken(JavadocParser.LEADING_ASTERISK, i); 2168 } 2169 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2170 public TerminalNode WS(int i) { 2171 return getToken(JavadocParser.WS, i); 2172 } 2173 public LiTagOpenContext(ParserRuleContext parent, int invokingState) { 2174 super(parent, invokingState); 2175 } 2176 @Override public int getRuleIndex() { return RULE_liTagOpen; } 2177 @Override 2178 public void enterRule(ParseTreeListener listener) { 2179 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagOpen(this); 2180 } 2181 @Override 2182 public void exitRule(ParseTreeListener listener) { 2183 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagOpen(this); 2184 } 2185 @Override 2186 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2187 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagOpen(this); 2188 else return visitor.visitChildren(this); 2189 } 2190 } 2191 2192 public final LiTagOpenContext liTagOpen() throws RecognitionException { 2193 LiTagOpenContext _localctx = new LiTagOpenContext(_ctx, getState()); 2194 enterRule(_localctx, 18, RULE_liTagOpen); 2195 int _la; 2196 try { 2197 enterOuterAlt(_localctx, 1); 2198 { 2199 setState(375); 2200 match(OPEN); 2201 setState(376); 2202 match(LI_HTML_TAG_NAME); 2203 setState(383); 2204 _errHandler.sync(this); 2205 _la = _input.LA(1); 2206 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2207 { 2208 setState(381); 2209 _errHandler.sync(this); 2210 switch (_input.LA(1)) { 2211 case HTML_TAG_NAME: 2212 { 2213 setState(377); 2214 attribute(); 2215 } 2216 break; 2217 case NEWLINE: 2218 { 2219 setState(378); 2220 match(NEWLINE); 2221 } 2222 break; 2223 case LEADING_ASTERISK: 2224 { 2225 setState(379); 2226 match(LEADING_ASTERISK); 2227 } 2228 break; 2229 case WS: 2230 { 2231 setState(380); 2232 match(WS); 2233 } 2234 break; 2235 default: 2236 throw new NoViableAltException(this); 2237 } 2238 } 2239 setState(385); 2240 _errHandler.sync(this); 2241 _la = _input.LA(1); 2242 } 2243 setState(386); 2244 match(CLOSE); 2245 } 2246 } 2247 catch (RecognitionException re) { 2248 _localctx.exception = re; 2249 _errHandler.reportError(this, re); 2250 _errHandler.recover(this, re); 2251 } 2252 finally { 2253 exitRule(); 2254 } 2255 return _localctx; 2256 } 2257 2258 public static class LiTagCloseContext extends ParserRuleContext { 2259 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2260 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2261 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2262 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2263 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2264 public TerminalNode NEWLINE(int i) { 2265 return getToken(JavadocParser.NEWLINE, i); 2266 } 2267 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2268 public TerminalNode LEADING_ASTERISK(int i) { 2269 return getToken(JavadocParser.LEADING_ASTERISK, i); 2270 } 2271 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2272 public TerminalNode WS(int i) { 2273 return getToken(JavadocParser.WS, i); 2274 } 2275 public LiTagCloseContext(ParserRuleContext parent, int invokingState) { 2276 super(parent, invokingState); 2277 } 2278 @Override public int getRuleIndex() { return RULE_liTagClose; } 2279 @Override 2280 public void enterRule(ParseTreeListener listener) { 2281 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagClose(this); 2282 } 2283 @Override 2284 public void exitRule(ParseTreeListener listener) { 2285 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagClose(this); 2286 } 2287 @Override 2288 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2289 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagClose(this); 2290 else return visitor.visitChildren(this); 2291 } 2292 } 2293 2294 public final LiTagCloseContext liTagClose() throws RecognitionException { 2295 LiTagCloseContext _localctx = new LiTagCloseContext(_ctx, getState()); 2296 enterRule(_localctx, 20, RULE_liTagClose); 2297 int _la; 2298 try { 2299 enterOuterAlt(_localctx, 1); 2300 { 2301 setState(388); 2302 match(OPEN); 2303 setState(389); 2304 match(SLASH); 2305 setState(390); 2306 match(LI_HTML_TAG_NAME); 2307 setState(394); 2308 _errHandler.sync(this); 2309 _la = _input.LA(1); 2310 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2311 { 2312 { 2313 setState(391); 2314 _la = _input.LA(1); 2315 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2316 _errHandler.recoverInline(this); 2317 } 2318 else { 2319 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 2320 _errHandler.reportMatch(this); 2321 consume(); 2322 } 2323 } 2324 } 2325 setState(396); 2326 _errHandler.sync(this); 2327 _la = _input.LA(1); 2328 } 2329 setState(397); 2330 match(CLOSE); 2331 } 2332 } 2333 catch (RecognitionException re) { 2334 _localctx.exception = re; 2335 _errHandler.reportError(this, re); 2336 _errHandler.recover(this, re); 2337 } 2338 finally { 2339 exitRule(); 2340 } 2341 return _localctx; 2342 } 2343 2344 public static class LiContext extends ParserRuleContext { 2345 public LiTagOpenContext liTagOpen() { 2346 return getRuleContext(LiTagOpenContext.class,0); 2347 } 2348 public LiTagCloseContext liTagClose() { 2349 return getRuleContext(LiTagCloseContext.class,0); 2350 } 2351 public List<HtmlTagContext> htmlTag() { 2352 return getRuleContexts(HtmlTagContext.class); 2353 } 2354 public HtmlTagContext htmlTag(int i) { 2355 return getRuleContext(HtmlTagContext.class,i); 2356 } 2357 public List<SingletonTagContext> singletonTag() { 2358 return getRuleContexts(SingletonTagContext.class); 2359 } 2360 public SingletonTagContext singletonTag(int i) { 2361 return getRuleContext(SingletonTagContext.class,i); 2362 } 2363 public List<ParagraphContext> paragraph() { 2364 return getRuleContexts(ParagraphContext.class); 2365 } 2366 public ParagraphContext paragraph(int i) { 2367 return getRuleContext(ParagraphContext.class,i); 2368 } 2369 public List<TrContext> tr() { 2370 return getRuleContexts(TrContext.class); 2371 } 2372 public TrContext tr(int i) { 2373 return getRuleContext(TrContext.class,i); 2374 } 2375 public List<TdContext> td() { 2376 return getRuleContexts(TdContext.class); 2377 } 2378 public TdContext td(int i) { 2379 return getRuleContext(TdContext.class,i); 2380 } 2381 public List<ThContext> th() { 2382 return getRuleContexts(ThContext.class); 2383 } 2384 public ThContext th(int i) { 2385 return getRuleContext(ThContext.class,i); 2386 } 2387 public List<BodyContext> body() { 2388 return getRuleContexts(BodyContext.class); 2389 } 2390 public BodyContext body(int i) { 2391 return getRuleContext(BodyContext.class,i); 2392 } 2393 public List<ColgroupContext> colgroup() { 2394 return getRuleContexts(ColgroupContext.class); 2395 } 2396 public ColgroupContext colgroup(int i) { 2397 return getRuleContext(ColgroupContext.class,i); 2398 } 2399 public List<DdContext> dd() { 2400 return getRuleContexts(DdContext.class); 2401 } 2402 public DdContext dd(int i) { 2403 return getRuleContext(DdContext.class,i); 2404 } 2405 public List<DtContext> dt() { 2406 return getRuleContexts(DtContext.class); 2407 } 2408 public DtContext dt(int i) { 2409 return getRuleContext(DtContext.class,i); 2410 } 2411 public List<HeadContext> head() { 2412 return getRuleContexts(HeadContext.class); 2413 } 2414 public HeadContext head(int i) { 2415 return getRuleContext(HeadContext.class,i); 2416 } 2417 public List<HtmlContext> html() { 2418 return getRuleContexts(HtmlContext.class); 2419 } 2420 public HtmlContext html(int i) { 2421 return getRuleContext(HtmlContext.class,i); 2422 } 2423 public List<OptionContext> option() { 2424 return getRuleContexts(OptionContext.class); 2425 } 2426 public OptionContext option(int i) { 2427 return getRuleContext(OptionContext.class,i); 2428 } 2429 public List<TbodyContext> tbody() { 2430 return getRuleContexts(TbodyContext.class); 2431 } 2432 public TbodyContext tbody(int i) { 2433 return getRuleContext(TbodyContext.class,i); 2434 } 2435 public List<TheadContext> thead() { 2436 return getRuleContexts(TheadContext.class); 2437 } 2438 public TheadContext thead(int i) { 2439 return getRuleContext(TheadContext.class,i); 2440 } 2441 public List<TfootContext> tfoot() { 2442 return getRuleContexts(TfootContext.class); 2443 } 2444 public TfootContext tfoot(int i) { 2445 return getRuleContext(TfootContext.class,i); 2446 } 2447 public List<PTagOpenContext> pTagOpen() { 2448 return getRuleContexts(PTagOpenContext.class); 2449 } 2450 public PTagOpenContext pTagOpen(int i) { 2451 return getRuleContext(PTagOpenContext.class,i); 2452 } 2453 public List<TrTagOpenContext> trTagOpen() { 2454 return getRuleContexts(TrTagOpenContext.class); 2455 } 2456 public TrTagOpenContext trTagOpen(int i) { 2457 return getRuleContext(TrTagOpenContext.class,i); 2458 } 2459 public List<TdTagOpenContext> tdTagOpen() { 2460 return getRuleContexts(TdTagOpenContext.class); 2461 } 2462 public TdTagOpenContext tdTagOpen(int i) { 2463 return getRuleContext(TdTagOpenContext.class,i); 2464 } 2465 public List<ThTagOpenContext> thTagOpen() { 2466 return getRuleContexts(ThTagOpenContext.class); 2467 } 2468 public ThTagOpenContext thTagOpen(int i) { 2469 return getRuleContext(ThTagOpenContext.class,i); 2470 } 2471 public List<BodyTagOpenContext> bodyTagOpen() { 2472 return getRuleContexts(BodyTagOpenContext.class); 2473 } 2474 public BodyTagOpenContext bodyTagOpen(int i) { 2475 return getRuleContext(BodyTagOpenContext.class,i); 2476 } 2477 public List<ColgroupTagOpenContext> colgroupTagOpen() { 2478 return getRuleContexts(ColgroupTagOpenContext.class); 2479 } 2480 public ColgroupTagOpenContext colgroupTagOpen(int i) { 2481 return getRuleContext(ColgroupTagOpenContext.class,i); 2482 } 2483 public List<DdTagOpenContext> ddTagOpen() { 2484 return getRuleContexts(DdTagOpenContext.class); 2485 } 2486 public DdTagOpenContext ddTagOpen(int i) { 2487 return getRuleContext(DdTagOpenContext.class,i); 2488 } 2489 public List<DtTagOpenContext> dtTagOpen() { 2490 return getRuleContexts(DtTagOpenContext.class); 2491 } 2492 public DtTagOpenContext dtTagOpen(int i) { 2493 return getRuleContext(DtTagOpenContext.class,i); 2494 } 2495 public List<HeadTagOpenContext> headTagOpen() { 2496 return getRuleContexts(HeadTagOpenContext.class); 2497 } 2498 public HeadTagOpenContext headTagOpen(int i) { 2499 return getRuleContext(HeadTagOpenContext.class,i); 2500 } 2501 public List<HtmlTagOpenContext> htmlTagOpen() { 2502 return getRuleContexts(HtmlTagOpenContext.class); 2503 } 2504 public HtmlTagOpenContext htmlTagOpen(int i) { 2505 return getRuleContext(HtmlTagOpenContext.class,i); 2506 } 2507 public List<OptionTagOpenContext> optionTagOpen() { 2508 return getRuleContexts(OptionTagOpenContext.class); 2509 } 2510 public OptionTagOpenContext optionTagOpen(int i) { 2511 return getRuleContext(OptionTagOpenContext.class,i); 2512 } 2513 public List<TbodyTagOpenContext> tbodyTagOpen() { 2514 return getRuleContexts(TbodyTagOpenContext.class); 2515 } 2516 public TbodyTagOpenContext tbodyTagOpen(int i) { 2517 return getRuleContext(TbodyTagOpenContext.class,i); 2518 } 2519 public List<TheadTagOpenContext> theadTagOpen() { 2520 return getRuleContexts(TheadTagOpenContext.class); 2521 } 2522 public TheadTagOpenContext theadTagOpen(int i) { 2523 return getRuleContext(TheadTagOpenContext.class,i); 2524 } 2525 public List<TfootTagOpenContext> tfootTagOpen() { 2526 return getRuleContexts(TfootTagOpenContext.class); 2527 } 2528 public TfootTagOpenContext tfootTagOpen(int i) { 2529 return getRuleContext(TfootTagOpenContext.class,i); 2530 } 2531 public List<HtmlCommentContext> htmlComment() { 2532 return getRuleContexts(HtmlCommentContext.class); 2533 } 2534 public HtmlCommentContext htmlComment(int i) { 2535 return getRuleContext(HtmlCommentContext.class,i); 2536 } 2537 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 2538 public TerminalNode CDATA(int i) { 2539 return getToken(JavadocParser.CDATA, i); 2540 } 2541 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2542 public TerminalNode NEWLINE(int i) { 2543 return getToken(JavadocParser.NEWLINE, i); 2544 } 2545 public List<TextContext> text() { 2546 return getRuleContexts(TextContext.class); 2547 } 2548 public TextContext text(int i) { 2549 return getRuleContext(TextContext.class,i); 2550 } 2551 public List<JavadocInlineTagContext> javadocInlineTag() { 2552 return getRuleContexts(JavadocInlineTagContext.class); 2553 } 2554 public JavadocInlineTagContext javadocInlineTag(int i) { 2555 return getRuleContext(JavadocInlineTagContext.class,i); 2556 } 2557 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2558 public TerminalNode LEADING_ASTERISK(int i) { 2559 return getToken(JavadocParser.LEADING_ASTERISK, i); 2560 } 2561 public LiContext(ParserRuleContext parent, int invokingState) { 2562 super(parent, invokingState); 2563 } 2564 @Override public int getRuleIndex() { return RULE_li; } 2565 @Override 2566 public void enterRule(ParseTreeListener listener) { 2567 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLi(this); 2568 } 2569 @Override 2570 public void exitRule(ParseTreeListener listener) { 2571 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLi(this); 2572 } 2573 @Override 2574 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2575 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLi(this); 2576 else return visitor.visitChildren(this); 2577 } 2578 } 2579 2580 public final LiContext li() throws RecognitionException { 2581 LiContext _localctx = new LiContext(_ctx, getState()); 2582 enterRule(_localctx, 22, RULE_li); 2583 try { 2584 int _alt; 2585 enterOuterAlt(_localctx, 1); 2586 { 2587 setState(399); 2588 liTagOpen(); 2589 setState(439); 2590 _errHandler.sync(this); 2591 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 2592 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 2593 if ( _alt==1 ) { 2594 { 2595 setState(437); 2596 _errHandler.sync(this); 2597 switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) { 2598 case 1: 2599 { 2600 setState(400); 2601 htmlTag(); 2602 } 2603 break; 2604 case 2: 2605 { 2606 setState(401); 2607 singletonTag(); 2608 } 2609 break; 2610 case 3: 2611 { 2612 setState(402); 2613 paragraph(); 2614 } 2615 break; 2616 case 4: 2617 { 2618 setState(403); 2619 tr(); 2620 } 2621 break; 2622 case 5: 2623 { 2624 setState(404); 2625 td(); 2626 } 2627 break; 2628 case 6: 2629 { 2630 setState(405); 2631 th(); 2632 } 2633 break; 2634 case 7: 2635 { 2636 setState(406); 2637 body(); 2638 } 2639 break; 2640 case 8: 2641 { 2642 setState(407); 2643 colgroup(); 2644 } 2645 break; 2646 case 9: 2647 { 2648 setState(408); 2649 dd(); 2650 } 2651 break; 2652 case 10: 2653 { 2654 setState(409); 2655 dt(); 2656 } 2657 break; 2658 case 11: 2659 { 2660 setState(410); 2661 head(); 2662 } 2663 break; 2664 case 12: 2665 { 2666 setState(411); 2667 html(); 2668 } 2669 break; 2670 case 13: 2671 { 2672 setState(412); 2673 option(); 2674 } 2675 break; 2676 case 14: 2677 { 2678 setState(413); 2679 tbody(); 2680 } 2681 break; 2682 case 15: 2683 { 2684 setState(414); 2685 thead(); 2686 } 2687 break; 2688 case 16: 2689 { 2690 setState(415); 2691 tfoot(); 2692 } 2693 break; 2694 case 17: 2695 { 2696 setState(416); 2697 pTagOpen(); 2698 } 2699 break; 2700 case 18: 2701 { 2702 setState(417); 2703 trTagOpen(); 2704 } 2705 break; 2706 case 19: 2707 { 2708 setState(418); 2709 tdTagOpen(); 2710 } 2711 break; 2712 case 20: 2713 { 2714 setState(419); 2715 thTagOpen(); 2716 } 2717 break; 2718 case 21: 2719 { 2720 setState(420); 2721 bodyTagOpen(); 2722 } 2723 break; 2724 case 22: 2725 { 2726 setState(421); 2727 colgroupTagOpen(); 2728 } 2729 break; 2730 case 23: 2731 { 2732 setState(422); 2733 ddTagOpen(); 2734 } 2735 break; 2736 case 24: 2737 { 2738 setState(423); 2739 dtTagOpen(); 2740 } 2741 break; 2742 case 25: 2743 { 2744 setState(424); 2745 headTagOpen(); 2746 } 2747 break; 2748 case 26: 2749 { 2750 setState(425); 2751 htmlTagOpen(); 2752 } 2753 break; 2754 case 27: 2755 { 2756 setState(426); 2757 optionTagOpen(); 2758 } 2759 break; 2760 case 28: 2761 { 2762 setState(427); 2763 tbodyTagOpen(); 2764 } 2765 break; 2766 case 29: 2767 { 2768 setState(428); 2769 theadTagOpen(); 2770 } 2771 break; 2772 case 30: 2773 { 2774 setState(429); 2775 tfootTagOpen(); 2776 } 2777 break; 2778 case 31: 2779 { 2780 { 2781 setState(430); 2782 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2783 setState(431); 2784 match(LEADING_ASTERISK); 2785 } 2786 } 2787 break; 2788 case 32: 2789 { 2790 setState(432); 2791 htmlComment(); 2792 } 2793 break; 2794 case 33: 2795 { 2796 setState(433); 2797 match(CDATA); 2798 } 2799 break; 2800 case 34: 2801 { 2802 setState(434); 2803 match(NEWLINE); 2804 } 2805 break; 2806 case 35: 2807 { 2808 setState(435); 2809 text(); 2810 } 2811 break; 2812 case 36: 2813 { 2814 setState(436); 2815 javadocInlineTag(); 2816 } 2817 break; 2818 } 2819 } 2820 } 2821 setState(441); 2822 _errHandler.sync(this); 2823 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 2824 } 2825 setState(442); 2826 liTagClose(); 2827 } 2828 } 2829 catch (RecognitionException re) { 2830 _localctx.exception = re; 2831 _errHandler.reportError(this, re); 2832 _errHandler.recover(this, re); 2833 } 2834 finally { 2835 exitRule(); 2836 } 2837 return _localctx; 2838 } 2839 2840 public static class TrTagOpenContext extends ParserRuleContext { 2841 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2842 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2843 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2844 public List<AttributeContext> attribute() { 2845 return getRuleContexts(AttributeContext.class); 2846 } 2847 public AttributeContext attribute(int i) { 2848 return getRuleContext(AttributeContext.class,i); 2849 } 2850 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2851 public TerminalNode NEWLINE(int i) { 2852 return getToken(JavadocParser.NEWLINE, i); 2853 } 2854 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2855 public TerminalNode LEADING_ASTERISK(int i) { 2856 return getToken(JavadocParser.LEADING_ASTERISK, i); 2857 } 2858 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2859 public TerminalNode WS(int i) { 2860 return getToken(JavadocParser.WS, i); 2861 } 2862 public TrTagOpenContext(ParserRuleContext parent, int invokingState) { 2863 super(parent, invokingState); 2864 } 2865 @Override public int getRuleIndex() { return RULE_trTagOpen; } 2866 @Override 2867 public void enterRule(ParseTreeListener listener) { 2868 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagOpen(this); 2869 } 2870 @Override 2871 public void exitRule(ParseTreeListener listener) { 2872 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagOpen(this); 2873 } 2874 @Override 2875 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2876 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagOpen(this); 2877 else return visitor.visitChildren(this); 2878 } 2879 } 2880 2881 public final TrTagOpenContext trTagOpen() throws RecognitionException { 2882 TrTagOpenContext _localctx = new TrTagOpenContext(_ctx, getState()); 2883 enterRule(_localctx, 24, RULE_trTagOpen); 2884 int _la; 2885 try { 2886 enterOuterAlt(_localctx, 1); 2887 { 2888 setState(444); 2889 match(OPEN); 2890 setState(445); 2891 match(TR_HTML_TAG_NAME); 2892 setState(452); 2893 _errHandler.sync(this); 2894 _la = _input.LA(1); 2895 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2896 { 2897 setState(450); 2898 _errHandler.sync(this); 2899 switch (_input.LA(1)) { 2900 case HTML_TAG_NAME: 2901 { 2902 setState(446); 2903 attribute(); 2904 } 2905 break; 2906 case NEWLINE: 2907 { 2908 setState(447); 2909 match(NEWLINE); 2910 } 2911 break; 2912 case LEADING_ASTERISK: 2913 { 2914 setState(448); 2915 match(LEADING_ASTERISK); 2916 } 2917 break; 2918 case WS: 2919 { 2920 setState(449); 2921 match(WS); 2922 } 2923 break; 2924 default: 2925 throw new NoViableAltException(this); 2926 } 2927 } 2928 setState(454); 2929 _errHandler.sync(this); 2930 _la = _input.LA(1); 2931 } 2932 setState(455); 2933 match(CLOSE); 2934 } 2935 } 2936 catch (RecognitionException re) { 2937 _localctx.exception = re; 2938 _errHandler.reportError(this, re); 2939 _errHandler.recover(this, re); 2940 } 2941 finally { 2942 exitRule(); 2943 } 2944 return _localctx; 2945 } 2946 2947 public static class TrTagCloseContext extends ParserRuleContext { 2948 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2949 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2950 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2951 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2952 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2953 public TerminalNode NEWLINE(int i) { 2954 return getToken(JavadocParser.NEWLINE, i); 2955 } 2956 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2957 public TerminalNode LEADING_ASTERISK(int i) { 2958 return getToken(JavadocParser.LEADING_ASTERISK, i); 2959 } 2960 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2961 public TerminalNode WS(int i) { 2962 return getToken(JavadocParser.WS, i); 2963 } 2964 public TrTagCloseContext(ParserRuleContext parent, int invokingState) { 2965 super(parent, invokingState); 2966 } 2967 @Override public int getRuleIndex() { return RULE_trTagClose; } 2968 @Override 2969 public void enterRule(ParseTreeListener listener) { 2970 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagClose(this); 2971 } 2972 @Override 2973 public void exitRule(ParseTreeListener listener) { 2974 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagClose(this); 2975 } 2976 @Override 2977 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2978 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagClose(this); 2979 else return visitor.visitChildren(this); 2980 } 2981 } 2982 2983 public final TrTagCloseContext trTagClose() throws RecognitionException { 2984 TrTagCloseContext _localctx = new TrTagCloseContext(_ctx, getState()); 2985 enterRule(_localctx, 26, RULE_trTagClose); 2986 int _la; 2987 try { 2988 enterOuterAlt(_localctx, 1); 2989 { 2990 setState(457); 2991 match(OPEN); 2992 setState(458); 2993 match(SLASH); 2994 setState(459); 2995 match(TR_HTML_TAG_NAME); 2996 setState(463); 2997 _errHandler.sync(this); 2998 _la = _input.LA(1); 2999 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3000 { 3001 { 3002 setState(460); 3003 _la = _input.LA(1); 3004 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3005 _errHandler.recoverInline(this); 3006 } 3007 else { 3008 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3009 _errHandler.reportMatch(this); 3010 consume(); 3011 } 3012 } 3013 } 3014 setState(465); 3015 _errHandler.sync(this); 3016 _la = _input.LA(1); 3017 } 3018 setState(466); 3019 match(CLOSE); 3020 } 3021 } 3022 catch (RecognitionException re) { 3023 _localctx.exception = re; 3024 _errHandler.reportError(this, re); 3025 _errHandler.recover(this, re); 3026 } 3027 finally { 3028 exitRule(); 3029 } 3030 return _localctx; 3031 } 3032 3033 public static class TrContext extends ParserRuleContext { 3034 public TrTagOpenContext trTagOpen() { 3035 return getRuleContext(TrTagOpenContext.class,0); 3036 } 3037 public TrTagCloseContext trTagClose() { 3038 return getRuleContext(TrTagCloseContext.class,0); 3039 } 3040 public List<HtmlTagContext> htmlTag() { 3041 return getRuleContexts(HtmlTagContext.class); 3042 } 3043 public HtmlTagContext htmlTag(int i) { 3044 return getRuleContext(HtmlTagContext.class,i); 3045 } 3046 public List<SingletonTagContext> singletonTag() { 3047 return getRuleContexts(SingletonTagContext.class); 3048 } 3049 public SingletonTagContext singletonTag(int i) { 3050 return getRuleContext(SingletonTagContext.class,i); 3051 } 3052 public List<ParagraphContext> paragraph() { 3053 return getRuleContexts(ParagraphContext.class); 3054 } 3055 public ParagraphContext paragraph(int i) { 3056 return getRuleContext(ParagraphContext.class,i); 3057 } 3058 public List<LiContext> li() { 3059 return getRuleContexts(LiContext.class); 3060 } 3061 public LiContext li(int i) { 3062 return getRuleContext(LiContext.class,i); 3063 } 3064 public List<TdContext> td() { 3065 return getRuleContexts(TdContext.class); 3066 } 3067 public TdContext td(int i) { 3068 return getRuleContext(TdContext.class,i); 3069 } 3070 public List<ThContext> th() { 3071 return getRuleContexts(ThContext.class); 3072 } 3073 public ThContext th(int i) { 3074 return getRuleContext(ThContext.class,i); 3075 } 3076 public List<BodyContext> body() { 3077 return getRuleContexts(BodyContext.class); 3078 } 3079 public BodyContext body(int i) { 3080 return getRuleContext(BodyContext.class,i); 3081 } 3082 public List<ColgroupContext> colgroup() { 3083 return getRuleContexts(ColgroupContext.class); 3084 } 3085 public ColgroupContext colgroup(int i) { 3086 return getRuleContext(ColgroupContext.class,i); 3087 } 3088 public List<DdContext> dd() { 3089 return getRuleContexts(DdContext.class); 3090 } 3091 public DdContext dd(int i) { 3092 return getRuleContext(DdContext.class,i); 3093 } 3094 public List<DtContext> dt() { 3095 return getRuleContexts(DtContext.class); 3096 } 3097 public DtContext dt(int i) { 3098 return getRuleContext(DtContext.class,i); 3099 } 3100 public List<HeadContext> head() { 3101 return getRuleContexts(HeadContext.class); 3102 } 3103 public HeadContext head(int i) { 3104 return getRuleContext(HeadContext.class,i); 3105 } 3106 public List<HtmlContext> html() { 3107 return getRuleContexts(HtmlContext.class); 3108 } 3109 public HtmlContext html(int i) { 3110 return getRuleContext(HtmlContext.class,i); 3111 } 3112 public List<OptionContext> option() { 3113 return getRuleContexts(OptionContext.class); 3114 } 3115 public OptionContext option(int i) { 3116 return getRuleContext(OptionContext.class,i); 3117 } 3118 public List<TbodyContext> tbody() { 3119 return getRuleContexts(TbodyContext.class); 3120 } 3121 public TbodyContext tbody(int i) { 3122 return getRuleContext(TbodyContext.class,i); 3123 } 3124 public List<TheadContext> thead() { 3125 return getRuleContexts(TheadContext.class); 3126 } 3127 public TheadContext thead(int i) { 3128 return getRuleContext(TheadContext.class,i); 3129 } 3130 public List<TfootContext> tfoot() { 3131 return getRuleContexts(TfootContext.class); 3132 } 3133 public TfootContext tfoot(int i) { 3134 return getRuleContext(TfootContext.class,i); 3135 } 3136 public List<PTagOpenContext> pTagOpen() { 3137 return getRuleContexts(PTagOpenContext.class); 3138 } 3139 public PTagOpenContext pTagOpen(int i) { 3140 return getRuleContext(PTagOpenContext.class,i); 3141 } 3142 public List<LiTagOpenContext> liTagOpen() { 3143 return getRuleContexts(LiTagOpenContext.class); 3144 } 3145 public LiTagOpenContext liTagOpen(int i) { 3146 return getRuleContext(LiTagOpenContext.class,i); 3147 } 3148 public List<TdTagOpenContext> tdTagOpen() { 3149 return getRuleContexts(TdTagOpenContext.class); 3150 } 3151 public TdTagOpenContext tdTagOpen(int i) { 3152 return getRuleContext(TdTagOpenContext.class,i); 3153 } 3154 public List<ThTagOpenContext> thTagOpen() { 3155 return getRuleContexts(ThTagOpenContext.class); 3156 } 3157 public ThTagOpenContext thTagOpen(int i) { 3158 return getRuleContext(ThTagOpenContext.class,i); 3159 } 3160 public List<BodyTagOpenContext> bodyTagOpen() { 3161 return getRuleContexts(BodyTagOpenContext.class); 3162 } 3163 public BodyTagOpenContext bodyTagOpen(int i) { 3164 return getRuleContext(BodyTagOpenContext.class,i); 3165 } 3166 public List<ColgroupTagOpenContext> colgroupTagOpen() { 3167 return getRuleContexts(ColgroupTagOpenContext.class); 3168 } 3169 public ColgroupTagOpenContext colgroupTagOpen(int i) { 3170 return getRuleContext(ColgroupTagOpenContext.class,i); 3171 } 3172 public List<DdTagOpenContext> ddTagOpen() { 3173 return getRuleContexts(DdTagOpenContext.class); 3174 } 3175 public DdTagOpenContext ddTagOpen(int i) { 3176 return getRuleContext(DdTagOpenContext.class,i); 3177 } 3178 public List<DtTagOpenContext> dtTagOpen() { 3179 return getRuleContexts(DtTagOpenContext.class); 3180 } 3181 public DtTagOpenContext dtTagOpen(int i) { 3182 return getRuleContext(DtTagOpenContext.class,i); 3183 } 3184 public List<HeadTagOpenContext> headTagOpen() { 3185 return getRuleContexts(HeadTagOpenContext.class); 3186 } 3187 public HeadTagOpenContext headTagOpen(int i) { 3188 return getRuleContext(HeadTagOpenContext.class,i); 3189 } 3190 public List<HtmlTagOpenContext> htmlTagOpen() { 3191 return getRuleContexts(HtmlTagOpenContext.class); 3192 } 3193 public HtmlTagOpenContext htmlTagOpen(int i) { 3194 return getRuleContext(HtmlTagOpenContext.class,i); 3195 } 3196 public List<OptionTagOpenContext> optionTagOpen() { 3197 return getRuleContexts(OptionTagOpenContext.class); 3198 } 3199 public OptionTagOpenContext optionTagOpen(int i) { 3200 return getRuleContext(OptionTagOpenContext.class,i); 3201 } 3202 public List<TbodyTagOpenContext> tbodyTagOpen() { 3203 return getRuleContexts(TbodyTagOpenContext.class); 3204 } 3205 public TbodyTagOpenContext tbodyTagOpen(int i) { 3206 return getRuleContext(TbodyTagOpenContext.class,i); 3207 } 3208 public List<TheadTagOpenContext> theadTagOpen() { 3209 return getRuleContexts(TheadTagOpenContext.class); 3210 } 3211 public TheadTagOpenContext theadTagOpen(int i) { 3212 return getRuleContext(TheadTagOpenContext.class,i); 3213 } 3214 public List<TfootTagOpenContext> tfootTagOpen() { 3215 return getRuleContexts(TfootTagOpenContext.class); 3216 } 3217 public TfootTagOpenContext tfootTagOpen(int i) { 3218 return getRuleContext(TfootTagOpenContext.class,i); 3219 } 3220 public List<HtmlCommentContext> htmlComment() { 3221 return getRuleContexts(HtmlCommentContext.class); 3222 } 3223 public HtmlCommentContext htmlComment(int i) { 3224 return getRuleContext(HtmlCommentContext.class,i); 3225 } 3226 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3227 public TerminalNode CDATA(int i) { 3228 return getToken(JavadocParser.CDATA, i); 3229 } 3230 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3231 public TerminalNode NEWLINE(int i) { 3232 return getToken(JavadocParser.NEWLINE, i); 3233 } 3234 public List<TextContext> text() { 3235 return getRuleContexts(TextContext.class); 3236 } 3237 public TextContext text(int i) { 3238 return getRuleContext(TextContext.class,i); 3239 } 3240 public List<JavadocInlineTagContext> javadocInlineTag() { 3241 return getRuleContexts(JavadocInlineTagContext.class); 3242 } 3243 public JavadocInlineTagContext javadocInlineTag(int i) { 3244 return getRuleContext(JavadocInlineTagContext.class,i); 3245 } 3246 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3247 public TerminalNode LEADING_ASTERISK(int i) { 3248 return getToken(JavadocParser.LEADING_ASTERISK, i); 3249 } 3250 public TrContext(ParserRuleContext parent, int invokingState) { 3251 super(parent, invokingState); 3252 } 3253 @Override public int getRuleIndex() { return RULE_tr; } 3254 @Override 3255 public void enterRule(ParseTreeListener listener) { 3256 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTr(this); 3257 } 3258 @Override 3259 public void exitRule(ParseTreeListener listener) { 3260 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTr(this); 3261 } 3262 @Override 3263 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3264 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTr(this); 3265 else return visitor.visitChildren(this); 3266 } 3267 } 3268 3269 public final TrContext tr() throws RecognitionException { 3270 TrContext _localctx = new TrContext(_ctx, getState()); 3271 enterRule(_localctx, 28, RULE_tr); 3272 try { 3273 int _alt; 3274 enterOuterAlt(_localctx, 1); 3275 { 3276 setState(468); 3277 trTagOpen(); 3278 setState(508); 3279 _errHandler.sync(this); 3280 _alt = getInterpreter().adaptivePredict(_input,31,_ctx); 3281 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3282 if ( _alt==1 ) { 3283 { 3284 setState(506); 3285 _errHandler.sync(this); 3286 switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) { 3287 case 1: 3288 { 3289 setState(469); 3290 htmlTag(); 3291 } 3292 break; 3293 case 2: 3294 { 3295 setState(470); 3296 singletonTag(); 3297 } 3298 break; 3299 case 3: 3300 { 3301 setState(471); 3302 paragraph(); 3303 } 3304 break; 3305 case 4: 3306 { 3307 setState(472); 3308 li(); 3309 } 3310 break; 3311 case 5: 3312 { 3313 setState(473); 3314 td(); 3315 } 3316 break; 3317 case 6: 3318 { 3319 setState(474); 3320 th(); 3321 } 3322 break; 3323 case 7: 3324 { 3325 setState(475); 3326 body(); 3327 } 3328 break; 3329 case 8: 3330 { 3331 setState(476); 3332 colgroup(); 3333 } 3334 break; 3335 case 9: 3336 { 3337 setState(477); 3338 dd(); 3339 } 3340 break; 3341 case 10: 3342 { 3343 setState(478); 3344 dt(); 3345 } 3346 break; 3347 case 11: 3348 { 3349 setState(479); 3350 head(); 3351 } 3352 break; 3353 case 12: 3354 { 3355 setState(480); 3356 html(); 3357 } 3358 break; 3359 case 13: 3360 { 3361 setState(481); 3362 option(); 3363 } 3364 break; 3365 case 14: 3366 { 3367 setState(482); 3368 tbody(); 3369 } 3370 break; 3371 case 15: 3372 { 3373 setState(483); 3374 thead(); 3375 } 3376 break; 3377 case 16: 3378 { 3379 setState(484); 3380 tfoot(); 3381 } 3382 break; 3383 case 17: 3384 { 3385 setState(485); 3386 pTagOpen(); 3387 } 3388 break; 3389 case 18: 3390 { 3391 setState(486); 3392 liTagOpen(); 3393 } 3394 break; 3395 case 19: 3396 { 3397 setState(487); 3398 tdTagOpen(); 3399 } 3400 break; 3401 case 20: 3402 { 3403 setState(488); 3404 thTagOpen(); 3405 } 3406 break; 3407 case 21: 3408 { 3409 setState(489); 3410 bodyTagOpen(); 3411 } 3412 break; 3413 case 22: 3414 { 3415 setState(490); 3416 colgroupTagOpen(); 3417 } 3418 break; 3419 case 23: 3420 { 3421 setState(491); 3422 ddTagOpen(); 3423 } 3424 break; 3425 case 24: 3426 { 3427 setState(492); 3428 dtTagOpen(); 3429 } 3430 break; 3431 case 25: 3432 { 3433 setState(493); 3434 headTagOpen(); 3435 } 3436 break; 3437 case 26: 3438 { 3439 setState(494); 3440 htmlTagOpen(); 3441 } 3442 break; 3443 case 27: 3444 { 3445 setState(495); 3446 optionTagOpen(); 3447 } 3448 break; 3449 case 28: 3450 { 3451 setState(496); 3452 tbodyTagOpen(); 3453 } 3454 break; 3455 case 29: 3456 { 3457 setState(497); 3458 theadTagOpen(); 3459 } 3460 break; 3461 case 30: 3462 { 3463 setState(498); 3464 tfootTagOpen(); 3465 } 3466 break; 3467 case 31: 3468 { 3469 { 3470 setState(499); 3471 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 3472 setState(500); 3473 match(LEADING_ASTERISK); 3474 } 3475 } 3476 break; 3477 case 32: 3478 { 3479 setState(501); 3480 htmlComment(); 3481 } 3482 break; 3483 case 33: 3484 { 3485 setState(502); 3486 match(CDATA); 3487 } 3488 break; 3489 case 34: 3490 { 3491 setState(503); 3492 match(NEWLINE); 3493 } 3494 break; 3495 case 35: 3496 { 3497 setState(504); 3498 text(); 3499 } 3500 break; 3501 case 36: 3502 { 3503 setState(505); 3504 javadocInlineTag(); 3505 } 3506 break; 3507 } 3508 } 3509 } 3510 setState(510); 3511 _errHandler.sync(this); 3512 _alt = getInterpreter().adaptivePredict(_input,31,_ctx); 3513 } 3514 setState(511); 3515 trTagClose(); 3516 } 3517 } 3518 catch (RecognitionException re) { 3519 _localctx.exception = re; 3520 _errHandler.reportError(this, re); 3521 _errHandler.recover(this, re); 3522 } 3523 finally { 3524 exitRule(); 3525 } 3526 return _localctx; 3527 } 3528 3529 public static class TdTagOpenContext extends ParserRuleContext { 3530 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 3531 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3532 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 3533 public List<AttributeContext> attribute() { 3534 return getRuleContexts(AttributeContext.class); 3535 } 3536 public AttributeContext attribute(int i) { 3537 return getRuleContext(AttributeContext.class,i); 3538 } 3539 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3540 public TerminalNode NEWLINE(int i) { 3541 return getToken(JavadocParser.NEWLINE, i); 3542 } 3543 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3544 public TerminalNode LEADING_ASTERISK(int i) { 3545 return getToken(JavadocParser.LEADING_ASTERISK, i); 3546 } 3547 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3548 public TerminalNode WS(int i) { 3549 return getToken(JavadocParser.WS, i); 3550 } 3551 public TdTagOpenContext(ParserRuleContext parent, int invokingState) { 3552 super(parent, invokingState); 3553 } 3554 @Override public int getRuleIndex() { return RULE_tdTagOpen; } 3555 @Override 3556 public void enterRule(ParseTreeListener listener) { 3557 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagOpen(this); 3558 } 3559 @Override 3560 public void exitRule(ParseTreeListener listener) { 3561 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagOpen(this); 3562 } 3563 @Override 3564 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3565 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagOpen(this); 3566 else return visitor.visitChildren(this); 3567 } 3568 } 3569 3570 public final TdTagOpenContext tdTagOpen() throws RecognitionException { 3571 TdTagOpenContext _localctx = new TdTagOpenContext(_ctx, getState()); 3572 enterRule(_localctx, 30, RULE_tdTagOpen); 3573 int _la; 3574 try { 3575 enterOuterAlt(_localctx, 1); 3576 { 3577 setState(513); 3578 match(OPEN); 3579 setState(514); 3580 match(TD_HTML_TAG_NAME); 3581 setState(521); 3582 _errHandler.sync(this); 3583 _la = _input.LA(1); 3584 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 3585 { 3586 setState(519); 3587 _errHandler.sync(this); 3588 switch (_input.LA(1)) { 3589 case HTML_TAG_NAME: 3590 { 3591 setState(515); 3592 attribute(); 3593 } 3594 break; 3595 case NEWLINE: 3596 { 3597 setState(516); 3598 match(NEWLINE); 3599 } 3600 break; 3601 case LEADING_ASTERISK: 3602 { 3603 setState(517); 3604 match(LEADING_ASTERISK); 3605 } 3606 break; 3607 case WS: 3608 { 3609 setState(518); 3610 match(WS); 3611 } 3612 break; 3613 default: 3614 throw new NoViableAltException(this); 3615 } 3616 } 3617 setState(523); 3618 _errHandler.sync(this); 3619 _la = _input.LA(1); 3620 } 3621 setState(524); 3622 match(CLOSE); 3623 } 3624 } 3625 catch (RecognitionException re) { 3626 _localctx.exception = re; 3627 _errHandler.reportError(this, re); 3628 _errHandler.recover(this, re); 3629 } 3630 finally { 3631 exitRule(); 3632 } 3633 return _localctx; 3634 } 3635 3636 public static class TdTagCloseContext extends ParserRuleContext { 3637 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 3638 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 3639 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3640 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 3641 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3642 public TerminalNode NEWLINE(int i) { 3643 return getToken(JavadocParser.NEWLINE, i); 3644 } 3645 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3646 public TerminalNode LEADING_ASTERISK(int i) { 3647 return getToken(JavadocParser.LEADING_ASTERISK, i); 3648 } 3649 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3650 public TerminalNode WS(int i) { 3651 return getToken(JavadocParser.WS, i); 3652 } 3653 public TdTagCloseContext(ParserRuleContext parent, int invokingState) { 3654 super(parent, invokingState); 3655 } 3656 @Override public int getRuleIndex() { return RULE_tdTagClose; } 3657 @Override 3658 public void enterRule(ParseTreeListener listener) { 3659 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagClose(this); 3660 } 3661 @Override 3662 public void exitRule(ParseTreeListener listener) { 3663 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagClose(this); 3664 } 3665 @Override 3666 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3667 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagClose(this); 3668 else return visitor.visitChildren(this); 3669 } 3670 } 3671 3672 public final TdTagCloseContext tdTagClose() throws RecognitionException { 3673 TdTagCloseContext _localctx = new TdTagCloseContext(_ctx, getState()); 3674 enterRule(_localctx, 32, RULE_tdTagClose); 3675 int _la; 3676 try { 3677 enterOuterAlt(_localctx, 1); 3678 { 3679 setState(526); 3680 match(OPEN); 3681 setState(527); 3682 match(SLASH); 3683 setState(528); 3684 match(TD_HTML_TAG_NAME); 3685 setState(532); 3686 _errHandler.sync(this); 3687 _la = _input.LA(1); 3688 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3689 { 3690 { 3691 setState(529); 3692 _la = _input.LA(1); 3693 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3694 _errHandler.recoverInline(this); 3695 } 3696 else { 3697 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3698 _errHandler.reportMatch(this); 3699 consume(); 3700 } 3701 } 3702 } 3703 setState(534); 3704 _errHandler.sync(this); 3705 _la = _input.LA(1); 3706 } 3707 setState(535); 3708 match(CLOSE); 3709 } 3710 } 3711 catch (RecognitionException re) { 3712 _localctx.exception = re; 3713 _errHandler.reportError(this, re); 3714 _errHandler.recover(this, re); 3715 } 3716 finally { 3717 exitRule(); 3718 } 3719 return _localctx; 3720 } 3721 3722 public static class TdContext extends ParserRuleContext { 3723 public List<TdTagOpenContext> tdTagOpen() { 3724 return getRuleContexts(TdTagOpenContext.class); 3725 } 3726 public TdTagOpenContext tdTagOpen(int i) { 3727 return getRuleContext(TdTagOpenContext.class,i); 3728 } 3729 public TdTagCloseContext tdTagClose() { 3730 return getRuleContext(TdTagCloseContext.class,0); 3731 } 3732 public List<HtmlTagContext> htmlTag() { 3733 return getRuleContexts(HtmlTagContext.class); 3734 } 3735 public HtmlTagContext htmlTag(int i) { 3736 return getRuleContext(HtmlTagContext.class,i); 3737 } 3738 public List<SingletonTagContext> singletonTag() { 3739 return getRuleContexts(SingletonTagContext.class); 3740 } 3741 public SingletonTagContext singletonTag(int i) { 3742 return getRuleContext(SingletonTagContext.class,i); 3743 } 3744 public List<ParagraphContext> paragraph() { 3745 return getRuleContexts(ParagraphContext.class); 3746 } 3747 public ParagraphContext paragraph(int i) { 3748 return getRuleContext(ParagraphContext.class,i); 3749 } 3750 public List<LiContext> li() { 3751 return getRuleContexts(LiContext.class); 3752 } 3753 public LiContext li(int i) { 3754 return getRuleContext(LiContext.class,i); 3755 } 3756 public List<TrContext> tr() { 3757 return getRuleContexts(TrContext.class); 3758 } 3759 public TrContext tr(int i) { 3760 return getRuleContext(TrContext.class,i); 3761 } 3762 public List<ThContext> th() { 3763 return getRuleContexts(ThContext.class); 3764 } 3765 public ThContext th(int i) { 3766 return getRuleContext(ThContext.class,i); 3767 } 3768 public List<BodyContext> body() { 3769 return getRuleContexts(BodyContext.class); 3770 } 3771 public BodyContext body(int i) { 3772 return getRuleContext(BodyContext.class,i); 3773 } 3774 public List<ColgroupContext> colgroup() { 3775 return getRuleContexts(ColgroupContext.class); 3776 } 3777 public ColgroupContext colgroup(int i) { 3778 return getRuleContext(ColgroupContext.class,i); 3779 } 3780 public List<DdContext> dd() { 3781 return getRuleContexts(DdContext.class); 3782 } 3783 public DdContext dd(int i) { 3784 return getRuleContext(DdContext.class,i); 3785 } 3786 public List<DtContext> dt() { 3787 return getRuleContexts(DtContext.class); 3788 } 3789 public DtContext dt(int i) { 3790 return getRuleContext(DtContext.class,i); 3791 } 3792 public List<HeadContext> head() { 3793 return getRuleContexts(HeadContext.class); 3794 } 3795 public HeadContext head(int i) { 3796 return getRuleContext(HeadContext.class,i); 3797 } 3798 public List<HtmlContext> html() { 3799 return getRuleContexts(HtmlContext.class); 3800 } 3801 public HtmlContext html(int i) { 3802 return getRuleContext(HtmlContext.class,i); 3803 } 3804 public List<OptionContext> option() { 3805 return getRuleContexts(OptionContext.class); 3806 } 3807 public OptionContext option(int i) { 3808 return getRuleContext(OptionContext.class,i); 3809 } 3810 public List<TbodyContext> tbody() { 3811 return getRuleContexts(TbodyContext.class); 3812 } 3813 public TbodyContext tbody(int i) { 3814 return getRuleContext(TbodyContext.class,i); 3815 } 3816 public List<TheadContext> thead() { 3817 return getRuleContexts(TheadContext.class); 3818 } 3819 public TheadContext thead(int i) { 3820 return getRuleContext(TheadContext.class,i); 3821 } 3822 public List<TfootContext> tfoot() { 3823 return getRuleContexts(TfootContext.class); 3824 } 3825 public TfootContext tfoot(int i) { 3826 return getRuleContext(TfootContext.class,i); 3827 } 3828 public List<PTagOpenContext> pTagOpen() { 3829 return getRuleContexts(PTagOpenContext.class); 3830 } 3831 public PTagOpenContext pTagOpen(int i) { 3832 return getRuleContext(PTagOpenContext.class,i); 3833 } 3834 public List<LiTagOpenContext> liTagOpen() { 3835 return getRuleContexts(LiTagOpenContext.class); 3836 } 3837 public LiTagOpenContext liTagOpen(int i) { 3838 return getRuleContext(LiTagOpenContext.class,i); 3839 } 3840 public List<ThTagOpenContext> thTagOpen() { 3841 return getRuleContexts(ThTagOpenContext.class); 3842 } 3843 public ThTagOpenContext thTagOpen(int i) { 3844 return getRuleContext(ThTagOpenContext.class,i); 3845 } 3846 public List<BodyTagOpenContext> bodyTagOpen() { 3847 return getRuleContexts(BodyTagOpenContext.class); 3848 } 3849 public BodyTagOpenContext bodyTagOpen(int i) { 3850 return getRuleContext(BodyTagOpenContext.class,i); 3851 } 3852 public List<ColgroupTagOpenContext> colgroupTagOpen() { 3853 return getRuleContexts(ColgroupTagOpenContext.class); 3854 } 3855 public ColgroupTagOpenContext colgroupTagOpen(int i) { 3856 return getRuleContext(ColgroupTagOpenContext.class,i); 3857 } 3858 public List<DdTagOpenContext> ddTagOpen() { 3859 return getRuleContexts(DdTagOpenContext.class); 3860 } 3861 public DdTagOpenContext ddTagOpen(int i) { 3862 return getRuleContext(DdTagOpenContext.class,i); 3863 } 3864 public List<DtTagOpenContext> dtTagOpen() { 3865 return getRuleContexts(DtTagOpenContext.class); 3866 } 3867 public DtTagOpenContext dtTagOpen(int i) { 3868 return getRuleContext(DtTagOpenContext.class,i); 3869 } 3870 public List<HeadTagOpenContext> headTagOpen() { 3871 return getRuleContexts(HeadTagOpenContext.class); 3872 } 3873 public HeadTagOpenContext headTagOpen(int i) { 3874 return getRuleContext(HeadTagOpenContext.class,i); 3875 } 3876 public List<HtmlTagOpenContext> htmlTagOpen() { 3877 return getRuleContexts(HtmlTagOpenContext.class); 3878 } 3879 public HtmlTagOpenContext htmlTagOpen(int i) { 3880 return getRuleContext(HtmlTagOpenContext.class,i); 3881 } 3882 public List<OptionTagOpenContext> optionTagOpen() { 3883 return getRuleContexts(OptionTagOpenContext.class); 3884 } 3885 public OptionTagOpenContext optionTagOpen(int i) { 3886 return getRuleContext(OptionTagOpenContext.class,i); 3887 } 3888 public List<TbodyTagOpenContext> tbodyTagOpen() { 3889 return getRuleContexts(TbodyTagOpenContext.class); 3890 } 3891 public TbodyTagOpenContext tbodyTagOpen(int i) { 3892 return getRuleContext(TbodyTagOpenContext.class,i); 3893 } 3894 public List<TheadTagOpenContext> theadTagOpen() { 3895 return getRuleContexts(TheadTagOpenContext.class); 3896 } 3897 public TheadTagOpenContext theadTagOpen(int i) { 3898 return getRuleContext(TheadTagOpenContext.class,i); 3899 } 3900 public List<TfootTagOpenContext> tfootTagOpen() { 3901 return getRuleContexts(TfootTagOpenContext.class); 3902 } 3903 public TfootTagOpenContext tfootTagOpen(int i) { 3904 return getRuleContext(TfootTagOpenContext.class,i); 3905 } 3906 public List<HtmlCommentContext> htmlComment() { 3907 return getRuleContexts(HtmlCommentContext.class); 3908 } 3909 public HtmlCommentContext htmlComment(int i) { 3910 return getRuleContext(HtmlCommentContext.class,i); 3911 } 3912 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3913 public TerminalNode CDATA(int i) { 3914 return getToken(JavadocParser.CDATA, i); 3915 } 3916 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3917 public TerminalNode NEWLINE(int i) { 3918 return getToken(JavadocParser.NEWLINE, i); 3919 } 3920 public List<TextContext> text() { 3921 return getRuleContexts(TextContext.class); 3922 } 3923 public TextContext text(int i) { 3924 return getRuleContext(TextContext.class,i); 3925 } 3926 public List<JavadocInlineTagContext> javadocInlineTag() { 3927 return getRuleContexts(JavadocInlineTagContext.class); 3928 } 3929 public JavadocInlineTagContext javadocInlineTag(int i) { 3930 return getRuleContext(JavadocInlineTagContext.class,i); 3931 } 3932 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3933 public TerminalNode LEADING_ASTERISK(int i) { 3934 return getToken(JavadocParser.LEADING_ASTERISK, i); 3935 } 3936 public TdContext(ParserRuleContext parent, int invokingState) { 3937 super(parent, invokingState); 3938 } 3939 @Override public int getRuleIndex() { return RULE_td; } 3940 @Override 3941 public void enterRule(ParseTreeListener listener) { 3942 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTd(this); 3943 } 3944 @Override 3945 public void exitRule(ParseTreeListener listener) { 3946 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTd(this); 3947 } 3948 @Override 3949 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3950 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTd(this); 3951 else return visitor.visitChildren(this); 3952 } 3953 } 3954 3955 public final TdContext td() throws RecognitionException { 3956 TdContext _localctx = new TdContext(_ctx, getState()); 3957 enterRule(_localctx, 34, RULE_td); 3958 try { 3959 int _alt; 3960 enterOuterAlt(_localctx, 1); 3961 { 3962 setState(537); 3963 tdTagOpen(); 3964 setState(577); 3965 _errHandler.sync(this); 3966 _alt = getInterpreter().adaptivePredict(_input,36,_ctx); 3967 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3968 if ( _alt==1 ) { 3969 { 3970 setState(575); 3971 _errHandler.sync(this); 3972 switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { 3973 case 1: 3974 { 3975 setState(538); 3976 htmlTag(); 3977 } 3978 break; 3979 case 2: 3980 { 3981 setState(539); 3982 singletonTag(); 3983 } 3984 break; 3985 case 3: 3986 { 3987 setState(540); 3988 paragraph(); 3989 } 3990 break; 3991 case 4: 3992 { 3993 setState(541); 3994 li(); 3995 } 3996 break; 3997 case 5: 3998 { 3999 setState(542); 4000 tr(); 4001 } 4002 break; 4003 case 6: 4004 { 4005 setState(543); 4006 th(); 4007 } 4008 break; 4009 case 7: 4010 { 4011 setState(544); 4012 body(); 4013 } 4014 break; 4015 case 8: 4016 { 4017 setState(545); 4018 colgroup(); 4019 } 4020 break; 4021 case 9: 4022 { 4023 setState(546); 4024 dd(); 4025 } 4026 break; 4027 case 10: 4028 { 4029 setState(547); 4030 dt(); 4031 } 4032 break; 4033 case 11: 4034 { 4035 setState(548); 4036 head(); 4037 } 4038 break; 4039 case 12: 4040 { 4041 setState(549); 4042 html(); 4043 } 4044 break; 4045 case 13: 4046 { 4047 setState(550); 4048 option(); 4049 } 4050 break; 4051 case 14: 4052 { 4053 setState(551); 4054 tbody(); 4055 } 4056 break; 4057 case 15: 4058 { 4059 setState(552); 4060 thead(); 4061 } 4062 break; 4063 case 16: 4064 { 4065 setState(553); 4066 tfoot(); 4067 } 4068 break; 4069 case 17: 4070 { 4071 setState(554); 4072 pTagOpen(); 4073 } 4074 break; 4075 case 18: 4076 { 4077 setState(555); 4078 liTagOpen(); 4079 } 4080 break; 4081 case 19: 4082 { 4083 setState(556); 4084 tdTagOpen(); 4085 } 4086 break; 4087 case 20: 4088 { 4089 setState(557); 4090 thTagOpen(); 4091 } 4092 break; 4093 case 21: 4094 { 4095 setState(558); 4096 bodyTagOpen(); 4097 } 4098 break; 4099 case 22: 4100 { 4101 setState(559); 4102 colgroupTagOpen(); 4103 } 4104 break; 4105 case 23: 4106 { 4107 setState(560); 4108 ddTagOpen(); 4109 } 4110 break; 4111 case 24: 4112 { 4113 setState(561); 4114 dtTagOpen(); 4115 } 4116 break; 4117 case 25: 4118 { 4119 setState(562); 4120 headTagOpen(); 4121 } 4122 break; 4123 case 26: 4124 { 4125 setState(563); 4126 htmlTagOpen(); 4127 } 4128 break; 4129 case 27: 4130 { 4131 setState(564); 4132 optionTagOpen(); 4133 } 4134 break; 4135 case 28: 4136 { 4137 setState(565); 4138 tbodyTagOpen(); 4139 } 4140 break; 4141 case 29: 4142 { 4143 setState(566); 4144 theadTagOpen(); 4145 } 4146 break; 4147 case 30: 4148 { 4149 setState(567); 4150 tfootTagOpen(); 4151 } 4152 break; 4153 case 31: 4154 { 4155 { 4156 setState(568); 4157 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4158 setState(569); 4159 match(LEADING_ASTERISK); 4160 } 4161 } 4162 break; 4163 case 32: 4164 { 4165 setState(570); 4166 htmlComment(); 4167 } 4168 break; 4169 case 33: 4170 { 4171 setState(571); 4172 match(CDATA); 4173 } 4174 break; 4175 case 34: 4176 { 4177 setState(572); 4178 match(NEWLINE); 4179 } 4180 break; 4181 case 35: 4182 { 4183 setState(573); 4184 text(); 4185 } 4186 break; 4187 case 36: 4188 { 4189 setState(574); 4190 javadocInlineTag(); 4191 } 4192 break; 4193 } 4194 } 4195 } 4196 setState(579); 4197 _errHandler.sync(this); 4198 _alt = getInterpreter().adaptivePredict(_input,36,_ctx); 4199 } 4200 setState(580); 4201 tdTagClose(); 4202 } 4203 } 4204 catch (RecognitionException re) { 4205 _localctx.exception = re; 4206 _errHandler.reportError(this, re); 4207 _errHandler.recover(this, re); 4208 } 4209 finally { 4210 exitRule(); 4211 } 4212 return _localctx; 4213 } 4214 4215 public static class ThTagOpenContext extends ParserRuleContext { 4216 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4217 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4218 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4219 public List<AttributeContext> attribute() { 4220 return getRuleContexts(AttributeContext.class); 4221 } 4222 public AttributeContext attribute(int i) { 4223 return getRuleContext(AttributeContext.class,i); 4224 } 4225 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4226 public TerminalNode NEWLINE(int i) { 4227 return getToken(JavadocParser.NEWLINE, i); 4228 } 4229 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4230 public TerminalNode LEADING_ASTERISK(int i) { 4231 return getToken(JavadocParser.LEADING_ASTERISK, i); 4232 } 4233 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4234 public TerminalNode WS(int i) { 4235 return getToken(JavadocParser.WS, i); 4236 } 4237 public ThTagOpenContext(ParserRuleContext parent, int invokingState) { 4238 super(parent, invokingState); 4239 } 4240 @Override public int getRuleIndex() { return RULE_thTagOpen; } 4241 @Override 4242 public void enterRule(ParseTreeListener listener) { 4243 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagOpen(this); 4244 } 4245 @Override 4246 public void exitRule(ParseTreeListener listener) { 4247 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagOpen(this); 4248 } 4249 @Override 4250 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4251 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagOpen(this); 4252 else return visitor.visitChildren(this); 4253 } 4254 } 4255 4256 public final ThTagOpenContext thTagOpen() throws RecognitionException { 4257 ThTagOpenContext _localctx = new ThTagOpenContext(_ctx, getState()); 4258 enterRule(_localctx, 36, RULE_thTagOpen); 4259 int _la; 4260 try { 4261 enterOuterAlt(_localctx, 1); 4262 { 4263 setState(582); 4264 match(OPEN); 4265 setState(583); 4266 match(TH_HTML_TAG_NAME); 4267 setState(590); 4268 _errHandler.sync(this); 4269 _la = _input.LA(1); 4270 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4271 { 4272 setState(588); 4273 _errHandler.sync(this); 4274 switch (_input.LA(1)) { 4275 case HTML_TAG_NAME: 4276 { 4277 setState(584); 4278 attribute(); 4279 } 4280 break; 4281 case NEWLINE: 4282 { 4283 setState(585); 4284 match(NEWLINE); 4285 } 4286 break; 4287 case LEADING_ASTERISK: 4288 { 4289 setState(586); 4290 match(LEADING_ASTERISK); 4291 } 4292 break; 4293 case WS: 4294 { 4295 setState(587); 4296 match(WS); 4297 } 4298 break; 4299 default: 4300 throw new NoViableAltException(this); 4301 } 4302 } 4303 setState(592); 4304 _errHandler.sync(this); 4305 _la = _input.LA(1); 4306 } 4307 setState(593); 4308 match(CLOSE); 4309 } 4310 } 4311 catch (RecognitionException re) { 4312 _localctx.exception = re; 4313 _errHandler.reportError(this, re); 4314 _errHandler.recover(this, re); 4315 } 4316 finally { 4317 exitRule(); 4318 } 4319 return _localctx; 4320 } 4321 4322 public static class ThTagCloseContext extends ParserRuleContext { 4323 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4324 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4325 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4326 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4327 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4328 public TerminalNode NEWLINE(int i) { 4329 return getToken(JavadocParser.NEWLINE, i); 4330 } 4331 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4332 public TerminalNode LEADING_ASTERISK(int i) { 4333 return getToken(JavadocParser.LEADING_ASTERISK, i); 4334 } 4335 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4336 public TerminalNode WS(int i) { 4337 return getToken(JavadocParser.WS, i); 4338 } 4339 public ThTagCloseContext(ParserRuleContext parent, int invokingState) { 4340 super(parent, invokingState); 4341 } 4342 @Override public int getRuleIndex() { return RULE_thTagClose; } 4343 @Override 4344 public void enterRule(ParseTreeListener listener) { 4345 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagClose(this); 4346 } 4347 @Override 4348 public void exitRule(ParseTreeListener listener) { 4349 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagClose(this); 4350 } 4351 @Override 4352 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4353 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagClose(this); 4354 else return visitor.visitChildren(this); 4355 } 4356 } 4357 4358 public final ThTagCloseContext thTagClose() throws RecognitionException { 4359 ThTagCloseContext _localctx = new ThTagCloseContext(_ctx, getState()); 4360 enterRule(_localctx, 38, RULE_thTagClose); 4361 int _la; 4362 try { 4363 enterOuterAlt(_localctx, 1); 4364 { 4365 setState(595); 4366 match(OPEN); 4367 setState(596); 4368 match(SLASH); 4369 setState(597); 4370 match(TH_HTML_TAG_NAME); 4371 setState(601); 4372 _errHandler.sync(this); 4373 _la = _input.LA(1); 4374 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 4375 { 4376 { 4377 setState(598); 4378 _la = _input.LA(1); 4379 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 4380 _errHandler.recoverInline(this); 4381 } 4382 else { 4383 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 4384 _errHandler.reportMatch(this); 4385 consume(); 4386 } 4387 } 4388 } 4389 setState(603); 4390 _errHandler.sync(this); 4391 _la = _input.LA(1); 4392 } 4393 setState(604); 4394 match(CLOSE); 4395 } 4396 } 4397 catch (RecognitionException re) { 4398 _localctx.exception = re; 4399 _errHandler.reportError(this, re); 4400 _errHandler.recover(this, re); 4401 } 4402 finally { 4403 exitRule(); 4404 } 4405 return _localctx; 4406 } 4407 4408 public static class ThContext extends ParserRuleContext { 4409 public ThTagOpenContext thTagOpen() { 4410 return getRuleContext(ThTagOpenContext.class,0); 4411 } 4412 public ThTagCloseContext thTagClose() { 4413 return getRuleContext(ThTagCloseContext.class,0); 4414 } 4415 public List<HtmlTagContext> htmlTag() { 4416 return getRuleContexts(HtmlTagContext.class); 4417 } 4418 public HtmlTagContext htmlTag(int i) { 4419 return getRuleContext(HtmlTagContext.class,i); 4420 } 4421 public List<SingletonTagContext> singletonTag() { 4422 return getRuleContexts(SingletonTagContext.class); 4423 } 4424 public SingletonTagContext singletonTag(int i) { 4425 return getRuleContext(SingletonTagContext.class,i); 4426 } 4427 public List<ParagraphContext> paragraph() { 4428 return getRuleContexts(ParagraphContext.class); 4429 } 4430 public ParagraphContext paragraph(int i) { 4431 return getRuleContext(ParagraphContext.class,i); 4432 } 4433 public List<LiContext> li() { 4434 return getRuleContexts(LiContext.class); 4435 } 4436 public LiContext li(int i) { 4437 return getRuleContext(LiContext.class,i); 4438 } 4439 public List<TrContext> tr() { 4440 return getRuleContexts(TrContext.class); 4441 } 4442 public TrContext tr(int i) { 4443 return getRuleContext(TrContext.class,i); 4444 } 4445 public List<TdContext> td() { 4446 return getRuleContexts(TdContext.class); 4447 } 4448 public TdContext td(int i) { 4449 return getRuleContext(TdContext.class,i); 4450 } 4451 public List<BodyContext> body() { 4452 return getRuleContexts(BodyContext.class); 4453 } 4454 public BodyContext body(int i) { 4455 return getRuleContext(BodyContext.class,i); 4456 } 4457 public List<ColgroupContext> colgroup() { 4458 return getRuleContexts(ColgroupContext.class); 4459 } 4460 public ColgroupContext colgroup(int i) { 4461 return getRuleContext(ColgroupContext.class,i); 4462 } 4463 public List<DdContext> dd() { 4464 return getRuleContexts(DdContext.class); 4465 } 4466 public DdContext dd(int i) { 4467 return getRuleContext(DdContext.class,i); 4468 } 4469 public List<DtContext> dt() { 4470 return getRuleContexts(DtContext.class); 4471 } 4472 public DtContext dt(int i) { 4473 return getRuleContext(DtContext.class,i); 4474 } 4475 public List<HeadContext> head() { 4476 return getRuleContexts(HeadContext.class); 4477 } 4478 public HeadContext head(int i) { 4479 return getRuleContext(HeadContext.class,i); 4480 } 4481 public List<HtmlContext> html() { 4482 return getRuleContexts(HtmlContext.class); 4483 } 4484 public HtmlContext html(int i) { 4485 return getRuleContext(HtmlContext.class,i); 4486 } 4487 public List<OptionContext> option() { 4488 return getRuleContexts(OptionContext.class); 4489 } 4490 public OptionContext option(int i) { 4491 return getRuleContext(OptionContext.class,i); 4492 } 4493 public List<TbodyContext> tbody() { 4494 return getRuleContexts(TbodyContext.class); 4495 } 4496 public TbodyContext tbody(int i) { 4497 return getRuleContext(TbodyContext.class,i); 4498 } 4499 public List<TheadContext> thead() { 4500 return getRuleContexts(TheadContext.class); 4501 } 4502 public TheadContext thead(int i) { 4503 return getRuleContext(TheadContext.class,i); 4504 } 4505 public List<TfootContext> tfoot() { 4506 return getRuleContexts(TfootContext.class); 4507 } 4508 public TfootContext tfoot(int i) { 4509 return getRuleContext(TfootContext.class,i); 4510 } 4511 public List<PTagOpenContext> pTagOpen() { 4512 return getRuleContexts(PTagOpenContext.class); 4513 } 4514 public PTagOpenContext pTagOpen(int i) { 4515 return getRuleContext(PTagOpenContext.class,i); 4516 } 4517 public List<LiTagOpenContext> liTagOpen() { 4518 return getRuleContexts(LiTagOpenContext.class); 4519 } 4520 public LiTagOpenContext liTagOpen(int i) { 4521 return getRuleContext(LiTagOpenContext.class,i); 4522 } 4523 public List<TrTagOpenContext> trTagOpen() { 4524 return getRuleContexts(TrTagOpenContext.class); 4525 } 4526 public TrTagOpenContext trTagOpen(int i) { 4527 return getRuleContext(TrTagOpenContext.class,i); 4528 } 4529 public List<TdTagOpenContext> tdTagOpen() { 4530 return getRuleContexts(TdTagOpenContext.class); 4531 } 4532 public TdTagOpenContext tdTagOpen(int i) { 4533 return getRuleContext(TdTagOpenContext.class,i); 4534 } 4535 public List<BodyTagOpenContext> bodyTagOpen() { 4536 return getRuleContexts(BodyTagOpenContext.class); 4537 } 4538 public BodyTagOpenContext bodyTagOpen(int i) { 4539 return getRuleContext(BodyTagOpenContext.class,i); 4540 } 4541 public List<ColgroupTagOpenContext> colgroupTagOpen() { 4542 return getRuleContexts(ColgroupTagOpenContext.class); 4543 } 4544 public ColgroupTagOpenContext colgroupTagOpen(int i) { 4545 return getRuleContext(ColgroupTagOpenContext.class,i); 4546 } 4547 public List<DdTagOpenContext> ddTagOpen() { 4548 return getRuleContexts(DdTagOpenContext.class); 4549 } 4550 public DdTagOpenContext ddTagOpen(int i) { 4551 return getRuleContext(DdTagOpenContext.class,i); 4552 } 4553 public List<DtTagOpenContext> dtTagOpen() { 4554 return getRuleContexts(DtTagOpenContext.class); 4555 } 4556 public DtTagOpenContext dtTagOpen(int i) { 4557 return getRuleContext(DtTagOpenContext.class,i); 4558 } 4559 public List<HeadTagOpenContext> headTagOpen() { 4560 return getRuleContexts(HeadTagOpenContext.class); 4561 } 4562 public HeadTagOpenContext headTagOpen(int i) { 4563 return getRuleContext(HeadTagOpenContext.class,i); 4564 } 4565 public List<HtmlTagOpenContext> htmlTagOpen() { 4566 return getRuleContexts(HtmlTagOpenContext.class); 4567 } 4568 public HtmlTagOpenContext htmlTagOpen(int i) { 4569 return getRuleContext(HtmlTagOpenContext.class,i); 4570 } 4571 public List<OptionTagOpenContext> optionTagOpen() { 4572 return getRuleContexts(OptionTagOpenContext.class); 4573 } 4574 public OptionTagOpenContext optionTagOpen(int i) { 4575 return getRuleContext(OptionTagOpenContext.class,i); 4576 } 4577 public List<TbodyTagOpenContext> tbodyTagOpen() { 4578 return getRuleContexts(TbodyTagOpenContext.class); 4579 } 4580 public TbodyTagOpenContext tbodyTagOpen(int i) { 4581 return getRuleContext(TbodyTagOpenContext.class,i); 4582 } 4583 public List<TheadTagOpenContext> theadTagOpen() { 4584 return getRuleContexts(TheadTagOpenContext.class); 4585 } 4586 public TheadTagOpenContext theadTagOpen(int i) { 4587 return getRuleContext(TheadTagOpenContext.class,i); 4588 } 4589 public List<TfootTagOpenContext> tfootTagOpen() { 4590 return getRuleContexts(TfootTagOpenContext.class); 4591 } 4592 public TfootTagOpenContext tfootTagOpen(int i) { 4593 return getRuleContext(TfootTagOpenContext.class,i); 4594 } 4595 public List<HtmlCommentContext> htmlComment() { 4596 return getRuleContexts(HtmlCommentContext.class); 4597 } 4598 public HtmlCommentContext htmlComment(int i) { 4599 return getRuleContext(HtmlCommentContext.class,i); 4600 } 4601 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 4602 public TerminalNode CDATA(int i) { 4603 return getToken(JavadocParser.CDATA, i); 4604 } 4605 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4606 public TerminalNode NEWLINE(int i) { 4607 return getToken(JavadocParser.NEWLINE, i); 4608 } 4609 public List<TextContext> text() { 4610 return getRuleContexts(TextContext.class); 4611 } 4612 public TextContext text(int i) { 4613 return getRuleContext(TextContext.class,i); 4614 } 4615 public List<JavadocInlineTagContext> javadocInlineTag() { 4616 return getRuleContexts(JavadocInlineTagContext.class); 4617 } 4618 public JavadocInlineTagContext javadocInlineTag(int i) { 4619 return getRuleContext(JavadocInlineTagContext.class,i); 4620 } 4621 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4622 public TerminalNode LEADING_ASTERISK(int i) { 4623 return getToken(JavadocParser.LEADING_ASTERISK, i); 4624 } 4625 public ThContext(ParserRuleContext parent, int invokingState) { 4626 super(parent, invokingState); 4627 } 4628 @Override public int getRuleIndex() { return RULE_th; } 4629 @Override 4630 public void enterRule(ParseTreeListener listener) { 4631 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTh(this); 4632 } 4633 @Override 4634 public void exitRule(ParseTreeListener listener) { 4635 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTh(this); 4636 } 4637 @Override 4638 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4639 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTh(this); 4640 else return visitor.visitChildren(this); 4641 } 4642 } 4643 4644 public final ThContext th() throws RecognitionException { 4645 ThContext _localctx = new ThContext(_ctx, getState()); 4646 enterRule(_localctx, 40, RULE_th); 4647 try { 4648 int _alt; 4649 enterOuterAlt(_localctx, 1); 4650 { 4651 setState(606); 4652 thTagOpen(); 4653 setState(646); 4654 _errHandler.sync(this); 4655 _alt = getInterpreter().adaptivePredict(_input,41,_ctx); 4656 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 4657 if ( _alt==1 ) { 4658 { 4659 setState(644); 4660 _errHandler.sync(this); 4661 switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { 4662 case 1: 4663 { 4664 setState(607); 4665 htmlTag(); 4666 } 4667 break; 4668 case 2: 4669 { 4670 setState(608); 4671 singletonTag(); 4672 } 4673 break; 4674 case 3: 4675 { 4676 setState(609); 4677 paragraph(); 4678 } 4679 break; 4680 case 4: 4681 { 4682 setState(610); 4683 li(); 4684 } 4685 break; 4686 case 5: 4687 { 4688 setState(611); 4689 tr(); 4690 } 4691 break; 4692 case 6: 4693 { 4694 setState(612); 4695 td(); 4696 } 4697 break; 4698 case 7: 4699 { 4700 setState(613); 4701 body(); 4702 } 4703 break; 4704 case 8: 4705 { 4706 setState(614); 4707 colgroup(); 4708 } 4709 break; 4710 case 9: 4711 { 4712 setState(615); 4713 dd(); 4714 } 4715 break; 4716 case 10: 4717 { 4718 setState(616); 4719 dt(); 4720 } 4721 break; 4722 case 11: 4723 { 4724 setState(617); 4725 head(); 4726 } 4727 break; 4728 case 12: 4729 { 4730 setState(618); 4731 html(); 4732 } 4733 break; 4734 case 13: 4735 { 4736 setState(619); 4737 option(); 4738 } 4739 break; 4740 case 14: 4741 { 4742 setState(620); 4743 tbody(); 4744 } 4745 break; 4746 case 15: 4747 { 4748 setState(621); 4749 thead(); 4750 } 4751 break; 4752 case 16: 4753 { 4754 setState(622); 4755 tfoot(); 4756 } 4757 break; 4758 case 17: 4759 { 4760 setState(623); 4761 pTagOpen(); 4762 } 4763 break; 4764 case 18: 4765 { 4766 setState(624); 4767 liTagOpen(); 4768 } 4769 break; 4770 case 19: 4771 { 4772 setState(625); 4773 trTagOpen(); 4774 } 4775 break; 4776 case 20: 4777 { 4778 setState(626); 4779 tdTagOpen(); 4780 } 4781 break; 4782 case 21: 4783 { 4784 setState(627); 4785 bodyTagOpen(); 4786 } 4787 break; 4788 case 22: 4789 { 4790 setState(628); 4791 colgroupTagOpen(); 4792 } 4793 break; 4794 case 23: 4795 { 4796 setState(629); 4797 ddTagOpen(); 4798 } 4799 break; 4800 case 24: 4801 { 4802 setState(630); 4803 dtTagOpen(); 4804 } 4805 break; 4806 case 25: 4807 { 4808 setState(631); 4809 headTagOpen(); 4810 } 4811 break; 4812 case 26: 4813 { 4814 setState(632); 4815 htmlTagOpen(); 4816 } 4817 break; 4818 case 27: 4819 { 4820 setState(633); 4821 optionTagOpen(); 4822 } 4823 break; 4824 case 28: 4825 { 4826 setState(634); 4827 tbodyTagOpen(); 4828 } 4829 break; 4830 case 29: 4831 { 4832 setState(635); 4833 theadTagOpen(); 4834 } 4835 break; 4836 case 30: 4837 { 4838 setState(636); 4839 tfootTagOpen(); 4840 } 4841 break; 4842 case 31: 4843 { 4844 { 4845 setState(637); 4846 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4847 setState(638); 4848 match(LEADING_ASTERISK); 4849 } 4850 } 4851 break; 4852 case 32: 4853 { 4854 setState(639); 4855 htmlComment(); 4856 } 4857 break; 4858 case 33: 4859 { 4860 setState(640); 4861 match(CDATA); 4862 } 4863 break; 4864 case 34: 4865 { 4866 setState(641); 4867 match(NEWLINE); 4868 } 4869 break; 4870 case 35: 4871 { 4872 setState(642); 4873 text(); 4874 } 4875 break; 4876 case 36: 4877 { 4878 setState(643); 4879 javadocInlineTag(); 4880 } 4881 break; 4882 } 4883 } 4884 } 4885 setState(648); 4886 _errHandler.sync(this); 4887 _alt = getInterpreter().adaptivePredict(_input,41,_ctx); 4888 } 4889 setState(649); 4890 thTagClose(); 4891 } 4892 } 4893 catch (RecognitionException re) { 4894 _localctx.exception = re; 4895 _errHandler.reportError(this, re); 4896 _errHandler.recover(this, re); 4897 } 4898 finally { 4899 exitRule(); 4900 } 4901 return _localctx; 4902 } 4903 4904 public static class BodyTagOpenContext extends ParserRuleContext { 4905 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4906 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 4907 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4908 public List<AttributeContext> attribute() { 4909 return getRuleContexts(AttributeContext.class); 4910 } 4911 public AttributeContext attribute(int i) { 4912 return getRuleContext(AttributeContext.class,i); 4913 } 4914 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4915 public TerminalNode NEWLINE(int i) { 4916 return getToken(JavadocParser.NEWLINE, i); 4917 } 4918 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4919 public TerminalNode LEADING_ASTERISK(int i) { 4920 return getToken(JavadocParser.LEADING_ASTERISK, i); 4921 } 4922 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4923 public TerminalNode WS(int i) { 4924 return getToken(JavadocParser.WS, i); 4925 } 4926 public BodyTagOpenContext(ParserRuleContext parent, int invokingState) { 4927 super(parent, invokingState); 4928 } 4929 @Override public int getRuleIndex() { return RULE_bodyTagOpen; } 4930 @Override 4931 public void enterRule(ParseTreeListener listener) { 4932 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagOpen(this); 4933 } 4934 @Override 4935 public void exitRule(ParseTreeListener listener) { 4936 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagOpen(this); 4937 } 4938 @Override 4939 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4940 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagOpen(this); 4941 else return visitor.visitChildren(this); 4942 } 4943 } 4944 4945 public final BodyTagOpenContext bodyTagOpen() throws RecognitionException { 4946 BodyTagOpenContext _localctx = new BodyTagOpenContext(_ctx, getState()); 4947 enterRule(_localctx, 42, RULE_bodyTagOpen); 4948 int _la; 4949 try { 4950 enterOuterAlt(_localctx, 1); 4951 { 4952 setState(651); 4953 match(OPEN); 4954 setState(652); 4955 match(BODY_HTML_TAG_NAME); 4956 setState(659); 4957 _errHandler.sync(this); 4958 _la = _input.LA(1); 4959 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4960 { 4961 setState(657); 4962 _errHandler.sync(this); 4963 switch (_input.LA(1)) { 4964 case HTML_TAG_NAME: 4965 { 4966 setState(653); 4967 attribute(); 4968 } 4969 break; 4970 case NEWLINE: 4971 { 4972 setState(654); 4973 match(NEWLINE); 4974 } 4975 break; 4976 case LEADING_ASTERISK: 4977 { 4978 setState(655); 4979 match(LEADING_ASTERISK); 4980 } 4981 break; 4982 case WS: 4983 { 4984 setState(656); 4985 match(WS); 4986 } 4987 break; 4988 default: 4989 throw new NoViableAltException(this); 4990 } 4991 } 4992 setState(661); 4993 _errHandler.sync(this); 4994 _la = _input.LA(1); 4995 } 4996 setState(662); 4997 match(CLOSE); 4998 } 4999 } 5000 catch (RecognitionException re) { 5001 _localctx.exception = re; 5002 _errHandler.reportError(this, re); 5003 _errHandler.recover(this, re); 5004 } 5005 finally { 5006 exitRule(); 5007 } 5008 return _localctx; 5009 } 5010 5011 public static class BodyTagCloseContext extends ParserRuleContext { 5012 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5013 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 5014 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 5015 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5016 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5017 public TerminalNode NEWLINE(int i) { 5018 return getToken(JavadocParser.NEWLINE, i); 5019 } 5020 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5021 public TerminalNode LEADING_ASTERISK(int i) { 5022 return getToken(JavadocParser.LEADING_ASTERISK, i); 5023 } 5024 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5025 public TerminalNode WS(int i) { 5026 return getToken(JavadocParser.WS, i); 5027 } 5028 public BodyTagCloseContext(ParserRuleContext parent, int invokingState) { 5029 super(parent, invokingState); 5030 } 5031 @Override public int getRuleIndex() { return RULE_bodyTagClose; } 5032 @Override 5033 public void enterRule(ParseTreeListener listener) { 5034 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagClose(this); 5035 } 5036 @Override 5037 public void exitRule(ParseTreeListener listener) { 5038 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagClose(this); 5039 } 5040 @Override 5041 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5042 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagClose(this); 5043 else return visitor.visitChildren(this); 5044 } 5045 } 5046 5047 public final BodyTagCloseContext bodyTagClose() throws RecognitionException { 5048 BodyTagCloseContext _localctx = new BodyTagCloseContext(_ctx, getState()); 5049 enterRule(_localctx, 44, RULE_bodyTagClose); 5050 int _la; 5051 try { 5052 enterOuterAlt(_localctx, 1); 5053 { 5054 setState(664); 5055 match(OPEN); 5056 setState(665); 5057 match(SLASH); 5058 setState(666); 5059 match(BODY_HTML_TAG_NAME); 5060 setState(670); 5061 _errHandler.sync(this); 5062 _la = _input.LA(1); 5063 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5064 { 5065 { 5066 setState(667); 5067 _la = _input.LA(1); 5068 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5069 _errHandler.recoverInline(this); 5070 } 5071 else { 5072 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 5073 _errHandler.reportMatch(this); 5074 consume(); 5075 } 5076 } 5077 } 5078 setState(672); 5079 _errHandler.sync(this); 5080 _la = _input.LA(1); 5081 } 5082 setState(673); 5083 match(CLOSE); 5084 } 5085 } 5086 catch (RecognitionException re) { 5087 _localctx.exception = re; 5088 _errHandler.reportError(this, re); 5089 _errHandler.recover(this, re); 5090 } 5091 finally { 5092 exitRule(); 5093 } 5094 return _localctx; 5095 } 5096 5097 public static class BodyContext extends ParserRuleContext { 5098 public BodyTagOpenContext bodyTagOpen() { 5099 return getRuleContext(BodyTagOpenContext.class,0); 5100 } 5101 public BodyTagCloseContext bodyTagClose() { 5102 return getRuleContext(BodyTagCloseContext.class,0); 5103 } 5104 public List<HtmlTagContext> htmlTag() { 5105 return getRuleContexts(HtmlTagContext.class); 5106 } 5107 public HtmlTagContext htmlTag(int i) { 5108 return getRuleContext(HtmlTagContext.class,i); 5109 } 5110 public List<SingletonTagContext> singletonTag() { 5111 return getRuleContexts(SingletonTagContext.class); 5112 } 5113 public SingletonTagContext singletonTag(int i) { 5114 return getRuleContext(SingletonTagContext.class,i); 5115 } 5116 public List<ParagraphContext> paragraph() { 5117 return getRuleContexts(ParagraphContext.class); 5118 } 5119 public ParagraphContext paragraph(int i) { 5120 return getRuleContext(ParagraphContext.class,i); 5121 } 5122 public List<LiContext> li() { 5123 return getRuleContexts(LiContext.class); 5124 } 5125 public LiContext li(int i) { 5126 return getRuleContext(LiContext.class,i); 5127 } 5128 public List<TrContext> tr() { 5129 return getRuleContexts(TrContext.class); 5130 } 5131 public TrContext tr(int i) { 5132 return getRuleContext(TrContext.class,i); 5133 } 5134 public List<TdContext> td() { 5135 return getRuleContexts(TdContext.class); 5136 } 5137 public TdContext td(int i) { 5138 return getRuleContext(TdContext.class,i); 5139 } 5140 public List<ThContext> th() { 5141 return getRuleContexts(ThContext.class); 5142 } 5143 public ThContext th(int i) { 5144 return getRuleContext(ThContext.class,i); 5145 } 5146 public List<ColgroupContext> colgroup() { 5147 return getRuleContexts(ColgroupContext.class); 5148 } 5149 public ColgroupContext colgroup(int i) { 5150 return getRuleContext(ColgroupContext.class,i); 5151 } 5152 public List<DdContext> dd() { 5153 return getRuleContexts(DdContext.class); 5154 } 5155 public DdContext dd(int i) { 5156 return getRuleContext(DdContext.class,i); 5157 } 5158 public List<DtContext> dt() { 5159 return getRuleContexts(DtContext.class); 5160 } 5161 public DtContext dt(int i) { 5162 return getRuleContext(DtContext.class,i); 5163 } 5164 public List<HeadContext> head() { 5165 return getRuleContexts(HeadContext.class); 5166 } 5167 public HeadContext head(int i) { 5168 return getRuleContext(HeadContext.class,i); 5169 } 5170 public List<HtmlContext> html() { 5171 return getRuleContexts(HtmlContext.class); 5172 } 5173 public HtmlContext html(int i) { 5174 return getRuleContext(HtmlContext.class,i); 5175 } 5176 public List<OptionContext> option() { 5177 return getRuleContexts(OptionContext.class); 5178 } 5179 public OptionContext option(int i) { 5180 return getRuleContext(OptionContext.class,i); 5181 } 5182 public List<TbodyContext> tbody() { 5183 return getRuleContexts(TbodyContext.class); 5184 } 5185 public TbodyContext tbody(int i) { 5186 return getRuleContext(TbodyContext.class,i); 5187 } 5188 public List<TheadContext> thead() { 5189 return getRuleContexts(TheadContext.class); 5190 } 5191 public TheadContext thead(int i) { 5192 return getRuleContext(TheadContext.class,i); 5193 } 5194 public List<TfootContext> tfoot() { 5195 return getRuleContexts(TfootContext.class); 5196 } 5197 public TfootContext tfoot(int i) { 5198 return getRuleContext(TfootContext.class,i); 5199 } 5200 public List<PTagOpenContext> pTagOpen() { 5201 return getRuleContexts(PTagOpenContext.class); 5202 } 5203 public PTagOpenContext pTagOpen(int i) { 5204 return getRuleContext(PTagOpenContext.class,i); 5205 } 5206 public List<LiTagOpenContext> liTagOpen() { 5207 return getRuleContexts(LiTagOpenContext.class); 5208 } 5209 public LiTagOpenContext liTagOpen(int i) { 5210 return getRuleContext(LiTagOpenContext.class,i); 5211 } 5212 public List<TrTagOpenContext> trTagOpen() { 5213 return getRuleContexts(TrTagOpenContext.class); 5214 } 5215 public TrTagOpenContext trTagOpen(int i) { 5216 return getRuleContext(TrTagOpenContext.class,i); 5217 } 5218 public List<TdTagOpenContext> tdTagOpen() { 5219 return getRuleContexts(TdTagOpenContext.class); 5220 } 5221 public TdTagOpenContext tdTagOpen(int i) { 5222 return getRuleContext(TdTagOpenContext.class,i); 5223 } 5224 public List<ThTagOpenContext> thTagOpen() { 5225 return getRuleContexts(ThTagOpenContext.class); 5226 } 5227 public ThTagOpenContext thTagOpen(int i) { 5228 return getRuleContext(ThTagOpenContext.class,i); 5229 } 5230 public List<ColgroupTagOpenContext> colgroupTagOpen() { 5231 return getRuleContexts(ColgroupTagOpenContext.class); 5232 } 5233 public ColgroupTagOpenContext colgroupTagOpen(int i) { 5234 return getRuleContext(ColgroupTagOpenContext.class,i); 5235 } 5236 public List<DdTagOpenContext> ddTagOpen() { 5237 return getRuleContexts(DdTagOpenContext.class); 5238 } 5239 public DdTagOpenContext ddTagOpen(int i) { 5240 return getRuleContext(DdTagOpenContext.class,i); 5241 } 5242 public List<DtTagOpenContext> dtTagOpen() { 5243 return getRuleContexts(DtTagOpenContext.class); 5244 } 5245 public DtTagOpenContext dtTagOpen(int i) { 5246 return getRuleContext(DtTagOpenContext.class,i); 5247 } 5248 public List<HeadTagOpenContext> headTagOpen() { 5249 return getRuleContexts(HeadTagOpenContext.class); 5250 } 5251 public HeadTagOpenContext headTagOpen(int i) { 5252 return getRuleContext(HeadTagOpenContext.class,i); 5253 } 5254 public List<HtmlTagOpenContext> htmlTagOpen() { 5255 return getRuleContexts(HtmlTagOpenContext.class); 5256 } 5257 public HtmlTagOpenContext htmlTagOpen(int i) { 5258 return getRuleContext(HtmlTagOpenContext.class,i); 5259 } 5260 public List<OptionTagOpenContext> optionTagOpen() { 5261 return getRuleContexts(OptionTagOpenContext.class); 5262 } 5263 public OptionTagOpenContext optionTagOpen(int i) { 5264 return getRuleContext(OptionTagOpenContext.class,i); 5265 } 5266 public List<TbodyTagOpenContext> tbodyTagOpen() { 5267 return getRuleContexts(TbodyTagOpenContext.class); 5268 } 5269 public TbodyTagOpenContext tbodyTagOpen(int i) { 5270 return getRuleContext(TbodyTagOpenContext.class,i); 5271 } 5272 public List<TheadTagOpenContext> theadTagOpen() { 5273 return getRuleContexts(TheadTagOpenContext.class); 5274 } 5275 public TheadTagOpenContext theadTagOpen(int i) { 5276 return getRuleContext(TheadTagOpenContext.class,i); 5277 } 5278 public List<TfootTagOpenContext> tfootTagOpen() { 5279 return getRuleContexts(TfootTagOpenContext.class); 5280 } 5281 public TfootTagOpenContext tfootTagOpen(int i) { 5282 return getRuleContext(TfootTagOpenContext.class,i); 5283 } 5284 public List<HtmlCommentContext> htmlComment() { 5285 return getRuleContexts(HtmlCommentContext.class); 5286 } 5287 public HtmlCommentContext htmlComment(int i) { 5288 return getRuleContext(HtmlCommentContext.class,i); 5289 } 5290 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5291 public TerminalNode CDATA(int i) { 5292 return getToken(JavadocParser.CDATA, i); 5293 } 5294 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5295 public TerminalNode NEWLINE(int i) { 5296 return getToken(JavadocParser.NEWLINE, i); 5297 } 5298 public List<TextContext> text() { 5299 return getRuleContexts(TextContext.class); 5300 } 5301 public TextContext text(int i) { 5302 return getRuleContext(TextContext.class,i); 5303 } 5304 public List<JavadocInlineTagContext> javadocInlineTag() { 5305 return getRuleContexts(JavadocInlineTagContext.class); 5306 } 5307 public JavadocInlineTagContext javadocInlineTag(int i) { 5308 return getRuleContext(JavadocInlineTagContext.class,i); 5309 } 5310 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5311 public TerminalNode LEADING_ASTERISK(int i) { 5312 return getToken(JavadocParser.LEADING_ASTERISK, i); 5313 } 5314 public BodyContext(ParserRuleContext parent, int invokingState) { 5315 super(parent, invokingState); 5316 } 5317 @Override public int getRuleIndex() { return RULE_body; } 5318 @Override 5319 public void enterRule(ParseTreeListener listener) { 5320 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBody(this); 5321 } 5322 @Override 5323 public void exitRule(ParseTreeListener listener) { 5324 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBody(this); 5325 } 5326 @Override 5327 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5328 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBody(this); 5329 else return visitor.visitChildren(this); 5330 } 5331 } 5332 5333 public final BodyContext body() throws RecognitionException { 5334 BodyContext _localctx = new BodyContext(_ctx, getState()); 5335 enterRule(_localctx, 46, RULE_body); 5336 try { 5337 int _alt; 5338 enterOuterAlt(_localctx, 1); 5339 { 5340 setState(675); 5341 bodyTagOpen(); 5342 setState(715); 5343 _errHandler.sync(this); 5344 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5345 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5346 if ( _alt==1 ) { 5347 { 5348 setState(713); 5349 _errHandler.sync(this); 5350 switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { 5351 case 1: 5352 { 5353 setState(676); 5354 htmlTag(); 5355 } 5356 break; 5357 case 2: 5358 { 5359 setState(677); 5360 singletonTag(); 5361 } 5362 break; 5363 case 3: 5364 { 5365 setState(678); 5366 paragraph(); 5367 } 5368 break; 5369 case 4: 5370 { 5371 setState(679); 5372 li(); 5373 } 5374 break; 5375 case 5: 5376 { 5377 setState(680); 5378 tr(); 5379 } 5380 break; 5381 case 6: 5382 { 5383 setState(681); 5384 td(); 5385 } 5386 break; 5387 case 7: 5388 { 5389 setState(682); 5390 th(); 5391 } 5392 break; 5393 case 8: 5394 { 5395 setState(683); 5396 colgroup(); 5397 } 5398 break; 5399 case 9: 5400 { 5401 setState(684); 5402 dd(); 5403 } 5404 break; 5405 case 10: 5406 { 5407 setState(685); 5408 dt(); 5409 } 5410 break; 5411 case 11: 5412 { 5413 setState(686); 5414 head(); 5415 } 5416 break; 5417 case 12: 5418 { 5419 setState(687); 5420 html(); 5421 } 5422 break; 5423 case 13: 5424 { 5425 setState(688); 5426 option(); 5427 } 5428 break; 5429 case 14: 5430 { 5431 setState(689); 5432 tbody(); 5433 } 5434 break; 5435 case 15: 5436 { 5437 setState(690); 5438 thead(); 5439 } 5440 break; 5441 case 16: 5442 { 5443 setState(691); 5444 tfoot(); 5445 } 5446 break; 5447 case 17: 5448 { 5449 setState(692); 5450 pTagOpen(); 5451 } 5452 break; 5453 case 18: 5454 { 5455 setState(693); 5456 liTagOpen(); 5457 } 5458 break; 5459 case 19: 5460 { 5461 setState(694); 5462 trTagOpen(); 5463 } 5464 break; 5465 case 20: 5466 { 5467 setState(695); 5468 tdTagOpen(); 5469 } 5470 break; 5471 case 21: 5472 { 5473 setState(696); 5474 thTagOpen(); 5475 } 5476 break; 5477 case 22: 5478 { 5479 setState(697); 5480 colgroupTagOpen(); 5481 } 5482 break; 5483 case 23: 5484 { 5485 setState(698); 5486 ddTagOpen(); 5487 } 5488 break; 5489 case 24: 5490 { 5491 setState(699); 5492 dtTagOpen(); 5493 } 5494 break; 5495 case 25: 5496 { 5497 setState(700); 5498 headTagOpen(); 5499 } 5500 break; 5501 case 26: 5502 { 5503 setState(701); 5504 htmlTagOpen(); 5505 } 5506 break; 5507 case 27: 5508 { 5509 setState(702); 5510 optionTagOpen(); 5511 } 5512 break; 5513 case 28: 5514 { 5515 setState(703); 5516 tbodyTagOpen(); 5517 } 5518 break; 5519 case 29: 5520 { 5521 setState(704); 5522 theadTagOpen(); 5523 } 5524 break; 5525 case 30: 5526 { 5527 setState(705); 5528 tfootTagOpen(); 5529 } 5530 break; 5531 case 31: 5532 { 5533 { 5534 setState(706); 5535 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 5536 setState(707); 5537 match(LEADING_ASTERISK); 5538 } 5539 } 5540 break; 5541 case 32: 5542 { 5543 setState(708); 5544 htmlComment(); 5545 } 5546 break; 5547 case 33: 5548 { 5549 setState(709); 5550 match(CDATA); 5551 } 5552 break; 5553 case 34: 5554 { 5555 setState(710); 5556 match(NEWLINE); 5557 } 5558 break; 5559 case 35: 5560 { 5561 setState(711); 5562 text(); 5563 } 5564 break; 5565 case 36: 5566 { 5567 setState(712); 5568 javadocInlineTag(); 5569 } 5570 break; 5571 } 5572 } 5573 } 5574 setState(717); 5575 _errHandler.sync(this); 5576 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5577 } 5578 setState(718); 5579 bodyTagClose(); 5580 } 5581 } 5582 catch (RecognitionException re) { 5583 _localctx.exception = re; 5584 _errHandler.reportError(this, re); 5585 _errHandler.recover(this, re); 5586 } 5587 finally { 5588 exitRule(); 5589 } 5590 return _localctx; 5591 } 5592 5593 public static class ColgroupTagOpenContext extends ParserRuleContext { 5594 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5595 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5596 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5597 public List<AttributeContext> attribute() { 5598 return getRuleContexts(AttributeContext.class); 5599 } 5600 public AttributeContext attribute(int i) { 5601 return getRuleContext(AttributeContext.class,i); 5602 } 5603 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5604 public TerminalNode NEWLINE(int i) { 5605 return getToken(JavadocParser.NEWLINE, i); 5606 } 5607 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5608 public TerminalNode LEADING_ASTERISK(int i) { 5609 return getToken(JavadocParser.LEADING_ASTERISK, i); 5610 } 5611 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5612 public TerminalNode WS(int i) { 5613 return getToken(JavadocParser.WS, i); 5614 } 5615 public ColgroupTagOpenContext(ParserRuleContext parent, int invokingState) { 5616 super(parent, invokingState); 5617 } 5618 @Override public int getRuleIndex() { return RULE_colgroupTagOpen; } 5619 @Override 5620 public void enterRule(ParseTreeListener listener) { 5621 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagOpen(this); 5622 } 5623 @Override 5624 public void exitRule(ParseTreeListener listener) { 5625 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagOpen(this); 5626 } 5627 @Override 5628 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5629 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagOpen(this); 5630 else return visitor.visitChildren(this); 5631 } 5632 } 5633 5634 public final ColgroupTagOpenContext colgroupTagOpen() throws RecognitionException { 5635 ColgroupTagOpenContext _localctx = new ColgroupTagOpenContext(_ctx, getState()); 5636 enterRule(_localctx, 48, RULE_colgroupTagOpen); 5637 int _la; 5638 try { 5639 enterOuterAlt(_localctx, 1); 5640 { 5641 setState(720); 5642 match(OPEN); 5643 setState(721); 5644 match(COLGROUP_HTML_TAG_NAME); 5645 setState(728); 5646 _errHandler.sync(this); 5647 _la = _input.LA(1); 5648 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 5649 { 5650 setState(726); 5651 _errHandler.sync(this); 5652 switch (_input.LA(1)) { 5653 case HTML_TAG_NAME: 5654 { 5655 setState(722); 5656 attribute(); 5657 } 5658 break; 5659 case NEWLINE: 5660 { 5661 setState(723); 5662 match(NEWLINE); 5663 } 5664 break; 5665 case LEADING_ASTERISK: 5666 { 5667 setState(724); 5668 match(LEADING_ASTERISK); 5669 } 5670 break; 5671 case WS: 5672 { 5673 setState(725); 5674 match(WS); 5675 } 5676 break; 5677 default: 5678 throw new NoViableAltException(this); 5679 } 5680 } 5681 setState(730); 5682 _errHandler.sync(this); 5683 _la = _input.LA(1); 5684 } 5685 setState(731); 5686 match(CLOSE); 5687 } 5688 } 5689 catch (RecognitionException re) { 5690 _localctx.exception = re; 5691 _errHandler.reportError(this, re); 5692 _errHandler.recover(this, re); 5693 } 5694 finally { 5695 exitRule(); 5696 } 5697 return _localctx; 5698 } 5699 5700 public static class ColgroupTagCloseContext extends ParserRuleContext { 5701 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5702 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 5703 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5704 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5705 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5706 public TerminalNode NEWLINE(int i) { 5707 return getToken(JavadocParser.NEWLINE, i); 5708 } 5709 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5710 public TerminalNode LEADING_ASTERISK(int i) { 5711 return getToken(JavadocParser.LEADING_ASTERISK, i); 5712 } 5713 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5714 public TerminalNode WS(int i) { 5715 return getToken(JavadocParser.WS, i); 5716 } 5717 public ColgroupTagCloseContext(ParserRuleContext parent, int invokingState) { 5718 super(parent, invokingState); 5719 } 5720 @Override public int getRuleIndex() { return RULE_colgroupTagClose; } 5721 @Override 5722 public void enterRule(ParseTreeListener listener) { 5723 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagClose(this); 5724 } 5725 @Override 5726 public void exitRule(ParseTreeListener listener) { 5727 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagClose(this); 5728 } 5729 @Override 5730 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5731 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagClose(this); 5732 else return visitor.visitChildren(this); 5733 } 5734 } 5735 5736 public final ColgroupTagCloseContext colgroupTagClose() throws RecognitionException { 5737 ColgroupTagCloseContext _localctx = new ColgroupTagCloseContext(_ctx, getState()); 5738 enterRule(_localctx, 50, RULE_colgroupTagClose); 5739 int _la; 5740 try { 5741 enterOuterAlt(_localctx, 1); 5742 { 5743 setState(733); 5744 match(OPEN); 5745 setState(734); 5746 match(SLASH); 5747 setState(735); 5748 match(COLGROUP_HTML_TAG_NAME); 5749 setState(739); 5750 _errHandler.sync(this); 5751 _la = _input.LA(1); 5752 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5753 { 5754 { 5755 setState(736); 5756 _la = _input.LA(1); 5757 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5758 _errHandler.recoverInline(this); 5759 } 5760 else { 5761 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 5762 _errHandler.reportMatch(this); 5763 consume(); 5764 } 5765 } 5766 } 5767 setState(741); 5768 _errHandler.sync(this); 5769 _la = _input.LA(1); 5770 } 5771 setState(742); 5772 match(CLOSE); 5773 } 5774 } 5775 catch (RecognitionException re) { 5776 _localctx.exception = re; 5777 _errHandler.reportError(this, re); 5778 _errHandler.recover(this, re); 5779 } 5780 finally { 5781 exitRule(); 5782 } 5783 return _localctx; 5784 } 5785 5786 public static class ColgroupContext extends ParserRuleContext { 5787 public ColgroupTagOpenContext colgroupTagOpen() { 5788 return getRuleContext(ColgroupTagOpenContext.class,0); 5789 } 5790 public ColgroupTagCloseContext colgroupTagClose() { 5791 return getRuleContext(ColgroupTagCloseContext.class,0); 5792 } 5793 public List<HtmlTagContext> htmlTag() { 5794 return getRuleContexts(HtmlTagContext.class); 5795 } 5796 public HtmlTagContext htmlTag(int i) { 5797 return getRuleContext(HtmlTagContext.class,i); 5798 } 5799 public List<SingletonTagContext> singletonTag() { 5800 return getRuleContexts(SingletonTagContext.class); 5801 } 5802 public SingletonTagContext singletonTag(int i) { 5803 return getRuleContext(SingletonTagContext.class,i); 5804 } 5805 public List<ParagraphContext> paragraph() { 5806 return getRuleContexts(ParagraphContext.class); 5807 } 5808 public ParagraphContext paragraph(int i) { 5809 return getRuleContext(ParagraphContext.class,i); 5810 } 5811 public List<LiContext> li() { 5812 return getRuleContexts(LiContext.class); 5813 } 5814 public LiContext li(int i) { 5815 return getRuleContext(LiContext.class,i); 5816 } 5817 public List<TrContext> tr() { 5818 return getRuleContexts(TrContext.class); 5819 } 5820 public TrContext tr(int i) { 5821 return getRuleContext(TrContext.class,i); 5822 } 5823 public List<TdContext> td() { 5824 return getRuleContexts(TdContext.class); 5825 } 5826 public TdContext td(int i) { 5827 return getRuleContext(TdContext.class,i); 5828 } 5829 public List<ThContext> th() { 5830 return getRuleContexts(ThContext.class); 5831 } 5832 public ThContext th(int i) { 5833 return getRuleContext(ThContext.class,i); 5834 } 5835 public List<BodyContext> body() { 5836 return getRuleContexts(BodyContext.class); 5837 } 5838 public BodyContext body(int i) { 5839 return getRuleContext(BodyContext.class,i); 5840 } 5841 public List<DdContext> dd() { 5842 return getRuleContexts(DdContext.class); 5843 } 5844 public DdContext dd(int i) { 5845 return getRuleContext(DdContext.class,i); 5846 } 5847 public List<DtContext> dt() { 5848 return getRuleContexts(DtContext.class); 5849 } 5850 public DtContext dt(int i) { 5851 return getRuleContext(DtContext.class,i); 5852 } 5853 public List<HeadContext> head() { 5854 return getRuleContexts(HeadContext.class); 5855 } 5856 public HeadContext head(int i) { 5857 return getRuleContext(HeadContext.class,i); 5858 } 5859 public List<HtmlContext> html() { 5860 return getRuleContexts(HtmlContext.class); 5861 } 5862 public HtmlContext html(int i) { 5863 return getRuleContext(HtmlContext.class,i); 5864 } 5865 public List<OptionContext> option() { 5866 return getRuleContexts(OptionContext.class); 5867 } 5868 public OptionContext option(int i) { 5869 return getRuleContext(OptionContext.class,i); 5870 } 5871 public List<TbodyContext> tbody() { 5872 return getRuleContexts(TbodyContext.class); 5873 } 5874 public TbodyContext tbody(int i) { 5875 return getRuleContext(TbodyContext.class,i); 5876 } 5877 public List<TheadContext> thead() { 5878 return getRuleContexts(TheadContext.class); 5879 } 5880 public TheadContext thead(int i) { 5881 return getRuleContext(TheadContext.class,i); 5882 } 5883 public List<TfootContext> tfoot() { 5884 return getRuleContexts(TfootContext.class); 5885 } 5886 public TfootContext tfoot(int i) { 5887 return getRuleContext(TfootContext.class,i); 5888 } 5889 public List<PTagOpenContext> pTagOpen() { 5890 return getRuleContexts(PTagOpenContext.class); 5891 } 5892 public PTagOpenContext pTagOpen(int i) { 5893 return getRuleContext(PTagOpenContext.class,i); 5894 } 5895 public List<LiTagOpenContext> liTagOpen() { 5896 return getRuleContexts(LiTagOpenContext.class); 5897 } 5898 public LiTagOpenContext liTagOpen(int i) { 5899 return getRuleContext(LiTagOpenContext.class,i); 5900 } 5901 public List<TrTagOpenContext> trTagOpen() { 5902 return getRuleContexts(TrTagOpenContext.class); 5903 } 5904 public TrTagOpenContext trTagOpen(int i) { 5905 return getRuleContext(TrTagOpenContext.class,i); 5906 } 5907 public List<TdTagOpenContext> tdTagOpen() { 5908 return getRuleContexts(TdTagOpenContext.class); 5909 } 5910 public TdTagOpenContext tdTagOpen(int i) { 5911 return getRuleContext(TdTagOpenContext.class,i); 5912 } 5913 public List<ThTagOpenContext> thTagOpen() { 5914 return getRuleContexts(ThTagOpenContext.class); 5915 } 5916 public ThTagOpenContext thTagOpen(int i) { 5917 return getRuleContext(ThTagOpenContext.class,i); 5918 } 5919 public List<BodyTagOpenContext> bodyTagOpen() { 5920 return getRuleContexts(BodyTagOpenContext.class); 5921 } 5922 public BodyTagOpenContext bodyTagOpen(int i) { 5923 return getRuleContext(BodyTagOpenContext.class,i); 5924 } 5925 public List<DdTagOpenContext> ddTagOpen() { 5926 return getRuleContexts(DdTagOpenContext.class); 5927 } 5928 public DdTagOpenContext ddTagOpen(int i) { 5929 return getRuleContext(DdTagOpenContext.class,i); 5930 } 5931 public List<DtTagOpenContext> dtTagOpen() { 5932 return getRuleContexts(DtTagOpenContext.class); 5933 } 5934 public DtTagOpenContext dtTagOpen(int i) { 5935 return getRuleContext(DtTagOpenContext.class,i); 5936 } 5937 public List<HeadTagOpenContext> headTagOpen() { 5938 return getRuleContexts(HeadTagOpenContext.class); 5939 } 5940 public HeadTagOpenContext headTagOpen(int i) { 5941 return getRuleContext(HeadTagOpenContext.class,i); 5942 } 5943 public List<HtmlTagOpenContext> htmlTagOpen() { 5944 return getRuleContexts(HtmlTagOpenContext.class); 5945 } 5946 public HtmlTagOpenContext htmlTagOpen(int i) { 5947 return getRuleContext(HtmlTagOpenContext.class,i); 5948 } 5949 public List<OptionTagOpenContext> optionTagOpen() { 5950 return getRuleContexts(OptionTagOpenContext.class); 5951 } 5952 public OptionTagOpenContext optionTagOpen(int i) { 5953 return getRuleContext(OptionTagOpenContext.class,i); 5954 } 5955 public List<TbodyTagOpenContext> tbodyTagOpen() { 5956 return getRuleContexts(TbodyTagOpenContext.class); 5957 } 5958 public TbodyTagOpenContext tbodyTagOpen(int i) { 5959 return getRuleContext(TbodyTagOpenContext.class,i); 5960 } 5961 public List<TheadTagOpenContext> theadTagOpen() { 5962 return getRuleContexts(TheadTagOpenContext.class); 5963 } 5964 public TheadTagOpenContext theadTagOpen(int i) { 5965 return getRuleContext(TheadTagOpenContext.class,i); 5966 } 5967 public List<TfootTagOpenContext> tfootTagOpen() { 5968 return getRuleContexts(TfootTagOpenContext.class); 5969 } 5970 public TfootTagOpenContext tfootTagOpen(int i) { 5971 return getRuleContext(TfootTagOpenContext.class,i); 5972 } 5973 public List<HtmlCommentContext> htmlComment() { 5974 return getRuleContexts(HtmlCommentContext.class); 5975 } 5976 public HtmlCommentContext htmlComment(int i) { 5977 return getRuleContext(HtmlCommentContext.class,i); 5978 } 5979 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5980 public TerminalNode CDATA(int i) { 5981 return getToken(JavadocParser.CDATA, i); 5982 } 5983 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5984 public TerminalNode NEWLINE(int i) { 5985 return getToken(JavadocParser.NEWLINE, i); 5986 } 5987 public List<TextContext> text() { 5988 return getRuleContexts(TextContext.class); 5989 } 5990 public TextContext text(int i) { 5991 return getRuleContext(TextContext.class,i); 5992 } 5993 public List<JavadocInlineTagContext> javadocInlineTag() { 5994 return getRuleContexts(JavadocInlineTagContext.class); 5995 } 5996 public JavadocInlineTagContext javadocInlineTag(int i) { 5997 return getRuleContext(JavadocInlineTagContext.class,i); 5998 } 5999 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6000 public TerminalNode LEADING_ASTERISK(int i) { 6001 return getToken(JavadocParser.LEADING_ASTERISK, i); 6002 } 6003 public ColgroupContext(ParserRuleContext parent, int invokingState) { 6004 super(parent, invokingState); 6005 } 6006 @Override public int getRuleIndex() { return RULE_colgroup; } 6007 @Override 6008 public void enterRule(ParseTreeListener listener) { 6009 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroup(this); 6010 } 6011 @Override 6012 public void exitRule(ParseTreeListener listener) { 6013 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroup(this); 6014 } 6015 @Override 6016 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6017 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroup(this); 6018 else return visitor.visitChildren(this); 6019 } 6020 } 6021 6022 public final ColgroupContext colgroup() throws RecognitionException { 6023 ColgroupContext _localctx = new ColgroupContext(_ctx, getState()); 6024 enterRule(_localctx, 52, RULE_colgroup); 6025 try { 6026 int _alt; 6027 enterOuterAlt(_localctx, 1); 6028 { 6029 setState(744); 6030 colgroupTagOpen(); 6031 setState(784); 6032 _errHandler.sync(this); 6033 _alt = getInterpreter().adaptivePredict(_input,51,_ctx); 6034 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6035 if ( _alt==1 ) { 6036 { 6037 setState(782); 6038 _errHandler.sync(this); 6039 switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { 6040 case 1: 6041 { 6042 setState(745); 6043 htmlTag(); 6044 } 6045 break; 6046 case 2: 6047 { 6048 setState(746); 6049 singletonTag(); 6050 } 6051 break; 6052 case 3: 6053 { 6054 setState(747); 6055 paragraph(); 6056 } 6057 break; 6058 case 4: 6059 { 6060 setState(748); 6061 li(); 6062 } 6063 break; 6064 case 5: 6065 { 6066 setState(749); 6067 tr(); 6068 } 6069 break; 6070 case 6: 6071 { 6072 setState(750); 6073 td(); 6074 } 6075 break; 6076 case 7: 6077 { 6078 setState(751); 6079 th(); 6080 } 6081 break; 6082 case 8: 6083 { 6084 setState(752); 6085 body(); 6086 } 6087 break; 6088 case 9: 6089 { 6090 setState(753); 6091 dd(); 6092 } 6093 break; 6094 case 10: 6095 { 6096 setState(754); 6097 dt(); 6098 } 6099 break; 6100 case 11: 6101 { 6102 setState(755); 6103 head(); 6104 } 6105 break; 6106 case 12: 6107 { 6108 setState(756); 6109 html(); 6110 } 6111 break; 6112 case 13: 6113 { 6114 setState(757); 6115 option(); 6116 } 6117 break; 6118 case 14: 6119 { 6120 setState(758); 6121 tbody(); 6122 } 6123 break; 6124 case 15: 6125 { 6126 setState(759); 6127 thead(); 6128 } 6129 break; 6130 case 16: 6131 { 6132 setState(760); 6133 tfoot(); 6134 } 6135 break; 6136 case 17: 6137 { 6138 setState(761); 6139 pTagOpen(); 6140 } 6141 break; 6142 case 18: 6143 { 6144 setState(762); 6145 liTagOpen(); 6146 } 6147 break; 6148 case 19: 6149 { 6150 setState(763); 6151 trTagOpen(); 6152 } 6153 break; 6154 case 20: 6155 { 6156 setState(764); 6157 tdTagOpen(); 6158 } 6159 break; 6160 case 21: 6161 { 6162 setState(765); 6163 thTagOpen(); 6164 } 6165 break; 6166 case 22: 6167 { 6168 setState(766); 6169 bodyTagOpen(); 6170 } 6171 break; 6172 case 23: 6173 { 6174 setState(767); 6175 ddTagOpen(); 6176 } 6177 break; 6178 case 24: 6179 { 6180 setState(768); 6181 dtTagOpen(); 6182 } 6183 break; 6184 case 25: 6185 { 6186 setState(769); 6187 headTagOpen(); 6188 } 6189 break; 6190 case 26: 6191 { 6192 setState(770); 6193 htmlTagOpen(); 6194 } 6195 break; 6196 case 27: 6197 { 6198 setState(771); 6199 optionTagOpen(); 6200 } 6201 break; 6202 case 28: 6203 { 6204 setState(772); 6205 tbodyTagOpen(); 6206 } 6207 break; 6208 case 29: 6209 { 6210 setState(773); 6211 theadTagOpen(); 6212 } 6213 break; 6214 case 30: 6215 { 6216 setState(774); 6217 tfootTagOpen(); 6218 } 6219 break; 6220 case 31: 6221 { 6222 { 6223 setState(775); 6224 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6225 setState(776); 6226 match(LEADING_ASTERISK); 6227 } 6228 } 6229 break; 6230 case 32: 6231 { 6232 setState(777); 6233 htmlComment(); 6234 } 6235 break; 6236 case 33: 6237 { 6238 setState(778); 6239 match(CDATA); 6240 } 6241 break; 6242 case 34: 6243 { 6244 setState(779); 6245 match(NEWLINE); 6246 } 6247 break; 6248 case 35: 6249 { 6250 setState(780); 6251 text(); 6252 } 6253 break; 6254 case 36: 6255 { 6256 setState(781); 6257 javadocInlineTag(); 6258 } 6259 break; 6260 } 6261 } 6262 } 6263 setState(786); 6264 _errHandler.sync(this); 6265 _alt = getInterpreter().adaptivePredict(_input,51,_ctx); 6266 } 6267 setState(787); 6268 colgroupTagClose(); 6269 } 6270 } 6271 catch (RecognitionException re) { 6272 _localctx.exception = re; 6273 _errHandler.reportError(this, re); 6274 _errHandler.recover(this, re); 6275 } 6276 finally { 6277 exitRule(); 6278 } 6279 return _localctx; 6280 } 6281 6282 public static class DdTagOpenContext extends ParserRuleContext { 6283 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6284 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6285 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6286 public List<AttributeContext> attribute() { 6287 return getRuleContexts(AttributeContext.class); 6288 } 6289 public AttributeContext attribute(int i) { 6290 return getRuleContext(AttributeContext.class,i); 6291 } 6292 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6293 public TerminalNode NEWLINE(int i) { 6294 return getToken(JavadocParser.NEWLINE, i); 6295 } 6296 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6297 public TerminalNode LEADING_ASTERISK(int i) { 6298 return getToken(JavadocParser.LEADING_ASTERISK, i); 6299 } 6300 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6301 public TerminalNode WS(int i) { 6302 return getToken(JavadocParser.WS, i); 6303 } 6304 public DdTagOpenContext(ParserRuleContext parent, int invokingState) { 6305 super(parent, invokingState); 6306 } 6307 @Override public int getRuleIndex() { return RULE_ddTagOpen; } 6308 @Override 6309 public void enterRule(ParseTreeListener listener) { 6310 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagOpen(this); 6311 } 6312 @Override 6313 public void exitRule(ParseTreeListener listener) { 6314 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagOpen(this); 6315 } 6316 @Override 6317 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6318 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagOpen(this); 6319 else return visitor.visitChildren(this); 6320 } 6321 } 6322 6323 public final DdTagOpenContext ddTagOpen() throws RecognitionException { 6324 DdTagOpenContext _localctx = new DdTagOpenContext(_ctx, getState()); 6325 enterRule(_localctx, 54, RULE_ddTagOpen); 6326 int _la; 6327 try { 6328 enterOuterAlt(_localctx, 1); 6329 { 6330 setState(789); 6331 match(OPEN); 6332 setState(790); 6333 match(DD_HTML_TAG_NAME); 6334 setState(797); 6335 _errHandler.sync(this); 6336 _la = _input.LA(1); 6337 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6338 { 6339 setState(795); 6340 _errHandler.sync(this); 6341 switch (_input.LA(1)) { 6342 case HTML_TAG_NAME: 6343 { 6344 setState(791); 6345 attribute(); 6346 } 6347 break; 6348 case NEWLINE: 6349 { 6350 setState(792); 6351 match(NEWLINE); 6352 } 6353 break; 6354 case LEADING_ASTERISK: 6355 { 6356 setState(793); 6357 match(LEADING_ASTERISK); 6358 } 6359 break; 6360 case WS: 6361 { 6362 setState(794); 6363 match(WS); 6364 } 6365 break; 6366 default: 6367 throw new NoViableAltException(this); 6368 } 6369 } 6370 setState(799); 6371 _errHandler.sync(this); 6372 _la = _input.LA(1); 6373 } 6374 setState(800); 6375 match(CLOSE); 6376 } 6377 } 6378 catch (RecognitionException re) { 6379 _localctx.exception = re; 6380 _errHandler.reportError(this, re); 6381 _errHandler.recover(this, re); 6382 } 6383 finally { 6384 exitRule(); 6385 } 6386 return _localctx; 6387 } 6388 6389 public static class DdTagCloseContext extends ParserRuleContext { 6390 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6391 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 6392 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6393 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6394 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6395 public TerminalNode NEWLINE(int i) { 6396 return getToken(JavadocParser.NEWLINE, i); 6397 } 6398 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6399 public TerminalNode LEADING_ASTERISK(int i) { 6400 return getToken(JavadocParser.LEADING_ASTERISK, i); 6401 } 6402 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6403 public TerminalNode WS(int i) { 6404 return getToken(JavadocParser.WS, i); 6405 } 6406 public DdTagCloseContext(ParserRuleContext parent, int invokingState) { 6407 super(parent, invokingState); 6408 } 6409 @Override public int getRuleIndex() { return RULE_ddTagClose; } 6410 @Override 6411 public void enterRule(ParseTreeListener listener) { 6412 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagClose(this); 6413 } 6414 @Override 6415 public void exitRule(ParseTreeListener listener) { 6416 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagClose(this); 6417 } 6418 @Override 6419 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6420 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagClose(this); 6421 else return visitor.visitChildren(this); 6422 } 6423 } 6424 6425 public final DdTagCloseContext ddTagClose() throws RecognitionException { 6426 DdTagCloseContext _localctx = new DdTagCloseContext(_ctx, getState()); 6427 enterRule(_localctx, 56, RULE_ddTagClose); 6428 int _la; 6429 try { 6430 enterOuterAlt(_localctx, 1); 6431 { 6432 setState(802); 6433 match(OPEN); 6434 setState(803); 6435 match(SLASH); 6436 setState(804); 6437 match(DD_HTML_TAG_NAME); 6438 setState(808); 6439 _errHandler.sync(this); 6440 _la = _input.LA(1); 6441 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 6442 { 6443 { 6444 setState(805); 6445 _la = _input.LA(1); 6446 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 6447 _errHandler.recoverInline(this); 6448 } 6449 else { 6450 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 6451 _errHandler.reportMatch(this); 6452 consume(); 6453 } 6454 } 6455 } 6456 setState(810); 6457 _errHandler.sync(this); 6458 _la = _input.LA(1); 6459 } 6460 setState(811); 6461 match(CLOSE); 6462 } 6463 } 6464 catch (RecognitionException re) { 6465 _localctx.exception = re; 6466 _errHandler.reportError(this, re); 6467 _errHandler.recover(this, re); 6468 } 6469 finally { 6470 exitRule(); 6471 } 6472 return _localctx; 6473 } 6474 6475 public static class DdContext extends ParserRuleContext { 6476 public DdTagOpenContext ddTagOpen() { 6477 return getRuleContext(DdTagOpenContext.class,0); 6478 } 6479 public DdTagCloseContext ddTagClose() { 6480 return getRuleContext(DdTagCloseContext.class,0); 6481 } 6482 public List<HtmlTagContext> htmlTag() { 6483 return getRuleContexts(HtmlTagContext.class); 6484 } 6485 public HtmlTagContext htmlTag(int i) { 6486 return getRuleContext(HtmlTagContext.class,i); 6487 } 6488 public List<SingletonTagContext> singletonTag() { 6489 return getRuleContexts(SingletonTagContext.class); 6490 } 6491 public SingletonTagContext singletonTag(int i) { 6492 return getRuleContext(SingletonTagContext.class,i); 6493 } 6494 public List<ParagraphContext> paragraph() { 6495 return getRuleContexts(ParagraphContext.class); 6496 } 6497 public ParagraphContext paragraph(int i) { 6498 return getRuleContext(ParagraphContext.class,i); 6499 } 6500 public List<LiContext> li() { 6501 return getRuleContexts(LiContext.class); 6502 } 6503 public LiContext li(int i) { 6504 return getRuleContext(LiContext.class,i); 6505 } 6506 public List<TrContext> tr() { 6507 return getRuleContexts(TrContext.class); 6508 } 6509 public TrContext tr(int i) { 6510 return getRuleContext(TrContext.class,i); 6511 } 6512 public List<TdContext> td() { 6513 return getRuleContexts(TdContext.class); 6514 } 6515 public TdContext td(int i) { 6516 return getRuleContext(TdContext.class,i); 6517 } 6518 public List<ThContext> th() { 6519 return getRuleContexts(ThContext.class); 6520 } 6521 public ThContext th(int i) { 6522 return getRuleContext(ThContext.class,i); 6523 } 6524 public List<BodyContext> body() { 6525 return getRuleContexts(BodyContext.class); 6526 } 6527 public BodyContext body(int i) { 6528 return getRuleContext(BodyContext.class,i); 6529 } 6530 public List<ColgroupContext> colgroup() { 6531 return getRuleContexts(ColgroupContext.class); 6532 } 6533 public ColgroupContext colgroup(int i) { 6534 return getRuleContext(ColgroupContext.class,i); 6535 } 6536 public List<DtContext> dt() { 6537 return getRuleContexts(DtContext.class); 6538 } 6539 public DtContext dt(int i) { 6540 return getRuleContext(DtContext.class,i); 6541 } 6542 public List<HeadContext> head() { 6543 return getRuleContexts(HeadContext.class); 6544 } 6545 public HeadContext head(int i) { 6546 return getRuleContext(HeadContext.class,i); 6547 } 6548 public List<HtmlContext> html() { 6549 return getRuleContexts(HtmlContext.class); 6550 } 6551 public HtmlContext html(int i) { 6552 return getRuleContext(HtmlContext.class,i); 6553 } 6554 public List<OptionContext> option() { 6555 return getRuleContexts(OptionContext.class); 6556 } 6557 public OptionContext option(int i) { 6558 return getRuleContext(OptionContext.class,i); 6559 } 6560 public List<TbodyContext> tbody() { 6561 return getRuleContexts(TbodyContext.class); 6562 } 6563 public TbodyContext tbody(int i) { 6564 return getRuleContext(TbodyContext.class,i); 6565 } 6566 public List<TheadContext> thead() { 6567 return getRuleContexts(TheadContext.class); 6568 } 6569 public TheadContext thead(int i) { 6570 return getRuleContext(TheadContext.class,i); 6571 } 6572 public List<TfootContext> tfoot() { 6573 return getRuleContexts(TfootContext.class); 6574 } 6575 public TfootContext tfoot(int i) { 6576 return getRuleContext(TfootContext.class,i); 6577 } 6578 public List<PTagOpenContext> pTagOpen() { 6579 return getRuleContexts(PTagOpenContext.class); 6580 } 6581 public PTagOpenContext pTagOpen(int i) { 6582 return getRuleContext(PTagOpenContext.class,i); 6583 } 6584 public List<LiTagOpenContext> liTagOpen() { 6585 return getRuleContexts(LiTagOpenContext.class); 6586 } 6587 public LiTagOpenContext liTagOpen(int i) { 6588 return getRuleContext(LiTagOpenContext.class,i); 6589 } 6590 public List<TrTagOpenContext> trTagOpen() { 6591 return getRuleContexts(TrTagOpenContext.class); 6592 } 6593 public TrTagOpenContext trTagOpen(int i) { 6594 return getRuleContext(TrTagOpenContext.class,i); 6595 } 6596 public List<TdTagOpenContext> tdTagOpen() { 6597 return getRuleContexts(TdTagOpenContext.class); 6598 } 6599 public TdTagOpenContext tdTagOpen(int i) { 6600 return getRuleContext(TdTagOpenContext.class,i); 6601 } 6602 public List<ThTagOpenContext> thTagOpen() { 6603 return getRuleContexts(ThTagOpenContext.class); 6604 } 6605 public ThTagOpenContext thTagOpen(int i) { 6606 return getRuleContext(ThTagOpenContext.class,i); 6607 } 6608 public List<BodyTagOpenContext> bodyTagOpen() { 6609 return getRuleContexts(BodyTagOpenContext.class); 6610 } 6611 public BodyTagOpenContext bodyTagOpen(int i) { 6612 return getRuleContext(BodyTagOpenContext.class,i); 6613 } 6614 public List<ColgroupTagOpenContext> colgroupTagOpen() { 6615 return getRuleContexts(ColgroupTagOpenContext.class); 6616 } 6617 public ColgroupTagOpenContext colgroupTagOpen(int i) { 6618 return getRuleContext(ColgroupTagOpenContext.class,i); 6619 } 6620 public List<DtTagOpenContext> dtTagOpen() { 6621 return getRuleContexts(DtTagOpenContext.class); 6622 } 6623 public DtTagOpenContext dtTagOpen(int i) { 6624 return getRuleContext(DtTagOpenContext.class,i); 6625 } 6626 public List<HeadTagOpenContext> headTagOpen() { 6627 return getRuleContexts(HeadTagOpenContext.class); 6628 } 6629 public HeadTagOpenContext headTagOpen(int i) { 6630 return getRuleContext(HeadTagOpenContext.class,i); 6631 } 6632 public List<HtmlTagOpenContext> htmlTagOpen() { 6633 return getRuleContexts(HtmlTagOpenContext.class); 6634 } 6635 public HtmlTagOpenContext htmlTagOpen(int i) { 6636 return getRuleContext(HtmlTagOpenContext.class,i); 6637 } 6638 public List<OptionTagOpenContext> optionTagOpen() { 6639 return getRuleContexts(OptionTagOpenContext.class); 6640 } 6641 public OptionTagOpenContext optionTagOpen(int i) { 6642 return getRuleContext(OptionTagOpenContext.class,i); 6643 } 6644 public List<TbodyTagOpenContext> tbodyTagOpen() { 6645 return getRuleContexts(TbodyTagOpenContext.class); 6646 } 6647 public TbodyTagOpenContext tbodyTagOpen(int i) { 6648 return getRuleContext(TbodyTagOpenContext.class,i); 6649 } 6650 public List<TheadTagOpenContext> theadTagOpen() { 6651 return getRuleContexts(TheadTagOpenContext.class); 6652 } 6653 public TheadTagOpenContext theadTagOpen(int i) { 6654 return getRuleContext(TheadTagOpenContext.class,i); 6655 } 6656 public List<TfootTagOpenContext> tfootTagOpen() { 6657 return getRuleContexts(TfootTagOpenContext.class); 6658 } 6659 public TfootTagOpenContext tfootTagOpen(int i) { 6660 return getRuleContext(TfootTagOpenContext.class,i); 6661 } 6662 public List<HtmlCommentContext> htmlComment() { 6663 return getRuleContexts(HtmlCommentContext.class); 6664 } 6665 public HtmlCommentContext htmlComment(int i) { 6666 return getRuleContext(HtmlCommentContext.class,i); 6667 } 6668 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 6669 public TerminalNode CDATA(int i) { 6670 return getToken(JavadocParser.CDATA, i); 6671 } 6672 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6673 public TerminalNode NEWLINE(int i) { 6674 return getToken(JavadocParser.NEWLINE, i); 6675 } 6676 public List<TextContext> text() { 6677 return getRuleContexts(TextContext.class); 6678 } 6679 public TextContext text(int i) { 6680 return getRuleContext(TextContext.class,i); 6681 } 6682 public List<JavadocInlineTagContext> javadocInlineTag() { 6683 return getRuleContexts(JavadocInlineTagContext.class); 6684 } 6685 public JavadocInlineTagContext javadocInlineTag(int i) { 6686 return getRuleContext(JavadocInlineTagContext.class,i); 6687 } 6688 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6689 public TerminalNode LEADING_ASTERISK(int i) { 6690 return getToken(JavadocParser.LEADING_ASTERISK, i); 6691 } 6692 public DdContext(ParserRuleContext parent, int invokingState) { 6693 super(parent, invokingState); 6694 } 6695 @Override public int getRuleIndex() { return RULE_dd; } 6696 @Override 6697 public void enterRule(ParseTreeListener listener) { 6698 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDd(this); 6699 } 6700 @Override 6701 public void exitRule(ParseTreeListener listener) { 6702 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDd(this); 6703 } 6704 @Override 6705 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6706 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDd(this); 6707 else return visitor.visitChildren(this); 6708 } 6709 } 6710 6711 public final DdContext dd() throws RecognitionException { 6712 DdContext _localctx = new DdContext(_ctx, getState()); 6713 enterRule(_localctx, 58, RULE_dd); 6714 try { 6715 int _alt; 6716 enterOuterAlt(_localctx, 1); 6717 { 6718 setState(813); 6719 ddTagOpen(); 6720 setState(853); 6721 _errHandler.sync(this); 6722 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6723 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6724 if ( _alt==1 ) { 6725 { 6726 setState(851); 6727 _errHandler.sync(this); 6728 switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { 6729 case 1: 6730 { 6731 setState(814); 6732 htmlTag(); 6733 } 6734 break; 6735 case 2: 6736 { 6737 setState(815); 6738 singletonTag(); 6739 } 6740 break; 6741 case 3: 6742 { 6743 setState(816); 6744 paragraph(); 6745 } 6746 break; 6747 case 4: 6748 { 6749 setState(817); 6750 li(); 6751 } 6752 break; 6753 case 5: 6754 { 6755 setState(818); 6756 tr(); 6757 } 6758 break; 6759 case 6: 6760 { 6761 setState(819); 6762 td(); 6763 } 6764 break; 6765 case 7: 6766 { 6767 setState(820); 6768 th(); 6769 } 6770 break; 6771 case 8: 6772 { 6773 setState(821); 6774 body(); 6775 } 6776 break; 6777 case 9: 6778 { 6779 setState(822); 6780 colgroup(); 6781 } 6782 break; 6783 case 10: 6784 { 6785 setState(823); 6786 dt(); 6787 } 6788 break; 6789 case 11: 6790 { 6791 setState(824); 6792 head(); 6793 } 6794 break; 6795 case 12: 6796 { 6797 setState(825); 6798 html(); 6799 } 6800 break; 6801 case 13: 6802 { 6803 setState(826); 6804 option(); 6805 } 6806 break; 6807 case 14: 6808 { 6809 setState(827); 6810 tbody(); 6811 } 6812 break; 6813 case 15: 6814 { 6815 setState(828); 6816 thead(); 6817 } 6818 break; 6819 case 16: 6820 { 6821 setState(829); 6822 tfoot(); 6823 } 6824 break; 6825 case 17: 6826 { 6827 setState(830); 6828 pTagOpen(); 6829 } 6830 break; 6831 case 18: 6832 { 6833 setState(831); 6834 liTagOpen(); 6835 } 6836 break; 6837 case 19: 6838 { 6839 setState(832); 6840 trTagOpen(); 6841 } 6842 break; 6843 case 20: 6844 { 6845 setState(833); 6846 tdTagOpen(); 6847 } 6848 break; 6849 case 21: 6850 { 6851 setState(834); 6852 thTagOpen(); 6853 } 6854 break; 6855 case 22: 6856 { 6857 setState(835); 6858 bodyTagOpen(); 6859 } 6860 break; 6861 case 23: 6862 { 6863 setState(836); 6864 colgroupTagOpen(); 6865 } 6866 break; 6867 case 24: 6868 { 6869 setState(837); 6870 dtTagOpen(); 6871 } 6872 break; 6873 case 25: 6874 { 6875 setState(838); 6876 headTagOpen(); 6877 } 6878 break; 6879 case 26: 6880 { 6881 setState(839); 6882 htmlTagOpen(); 6883 } 6884 break; 6885 case 27: 6886 { 6887 setState(840); 6888 optionTagOpen(); 6889 } 6890 break; 6891 case 28: 6892 { 6893 setState(841); 6894 tbodyTagOpen(); 6895 } 6896 break; 6897 case 29: 6898 { 6899 setState(842); 6900 theadTagOpen(); 6901 } 6902 break; 6903 case 30: 6904 { 6905 setState(843); 6906 tfootTagOpen(); 6907 } 6908 break; 6909 case 31: 6910 { 6911 { 6912 setState(844); 6913 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6914 setState(845); 6915 match(LEADING_ASTERISK); 6916 } 6917 } 6918 break; 6919 case 32: 6920 { 6921 setState(846); 6922 htmlComment(); 6923 } 6924 break; 6925 case 33: 6926 { 6927 setState(847); 6928 match(CDATA); 6929 } 6930 break; 6931 case 34: 6932 { 6933 setState(848); 6934 match(NEWLINE); 6935 } 6936 break; 6937 case 35: 6938 { 6939 setState(849); 6940 text(); 6941 } 6942 break; 6943 case 36: 6944 { 6945 setState(850); 6946 javadocInlineTag(); 6947 } 6948 break; 6949 } 6950 } 6951 } 6952 setState(855); 6953 _errHandler.sync(this); 6954 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6955 } 6956 setState(856); 6957 ddTagClose(); 6958 } 6959 } 6960 catch (RecognitionException re) { 6961 _localctx.exception = re; 6962 _errHandler.reportError(this, re); 6963 _errHandler.recover(this, re); 6964 } 6965 finally { 6966 exitRule(); 6967 } 6968 return _localctx; 6969 } 6970 6971 public static class DtTagOpenContext extends ParserRuleContext { 6972 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6973 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 6974 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6975 public List<AttributeContext> attribute() { 6976 return getRuleContexts(AttributeContext.class); 6977 } 6978 public AttributeContext attribute(int i) { 6979 return getRuleContext(AttributeContext.class,i); 6980 } 6981 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6982 public TerminalNode NEWLINE(int i) { 6983 return getToken(JavadocParser.NEWLINE, i); 6984 } 6985 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6986 public TerminalNode LEADING_ASTERISK(int i) { 6987 return getToken(JavadocParser.LEADING_ASTERISK, i); 6988 } 6989 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6990 public TerminalNode WS(int i) { 6991 return getToken(JavadocParser.WS, i); 6992 } 6993 public DtTagOpenContext(ParserRuleContext parent, int invokingState) { 6994 super(parent, invokingState); 6995 } 6996 @Override public int getRuleIndex() { return RULE_dtTagOpen; } 6997 @Override 6998 public void enterRule(ParseTreeListener listener) { 6999 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagOpen(this); 7000 } 7001 @Override 7002 public void exitRule(ParseTreeListener listener) { 7003 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagOpen(this); 7004 } 7005 @Override 7006 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7007 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagOpen(this); 7008 else return visitor.visitChildren(this); 7009 } 7010 } 7011 7012 public final DtTagOpenContext dtTagOpen() throws RecognitionException { 7013 DtTagOpenContext _localctx = new DtTagOpenContext(_ctx, getState()); 7014 enterRule(_localctx, 60, RULE_dtTagOpen); 7015 int _la; 7016 try { 7017 enterOuterAlt(_localctx, 1); 7018 { 7019 setState(858); 7020 match(OPEN); 7021 setState(859); 7022 match(DT_HTML_TAG_NAME); 7023 setState(866); 7024 _errHandler.sync(this); 7025 _la = _input.LA(1); 7026 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 7027 { 7028 setState(864); 7029 _errHandler.sync(this); 7030 switch (_input.LA(1)) { 7031 case HTML_TAG_NAME: 7032 { 7033 setState(860); 7034 attribute(); 7035 } 7036 break; 7037 case NEWLINE: 7038 { 7039 setState(861); 7040 match(NEWLINE); 7041 } 7042 break; 7043 case LEADING_ASTERISK: 7044 { 7045 setState(862); 7046 match(LEADING_ASTERISK); 7047 } 7048 break; 7049 case WS: 7050 { 7051 setState(863); 7052 match(WS); 7053 } 7054 break; 7055 default: 7056 throw new NoViableAltException(this); 7057 } 7058 } 7059 setState(868); 7060 _errHandler.sync(this); 7061 _la = _input.LA(1); 7062 } 7063 setState(869); 7064 match(CLOSE); 7065 } 7066 } 7067 catch (RecognitionException re) { 7068 _localctx.exception = re; 7069 _errHandler.reportError(this, re); 7070 _errHandler.recover(this, re); 7071 } 7072 finally { 7073 exitRule(); 7074 } 7075 return _localctx; 7076 } 7077 7078 public static class DtTagCloseContext extends ParserRuleContext { 7079 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7080 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7081 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 7082 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7083 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7084 public TerminalNode NEWLINE(int i) { 7085 return getToken(JavadocParser.NEWLINE, i); 7086 } 7087 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7088 public TerminalNode LEADING_ASTERISK(int i) { 7089 return getToken(JavadocParser.LEADING_ASTERISK, i); 7090 } 7091 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7092 public TerminalNode WS(int i) { 7093 return getToken(JavadocParser.WS, i); 7094 } 7095 public DtTagCloseContext(ParserRuleContext parent, int invokingState) { 7096 super(parent, invokingState); 7097 } 7098 @Override public int getRuleIndex() { return RULE_dtTagClose; } 7099 @Override 7100 public void enterRule(ParseTreeListener listener) { 7101 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagClose(this); 7102 } 7103 @Override 7104 public void exitRule(ParseTreeListener listener) { 7105 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagClose(this); 7106 } 7107 @Override 7108 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7109 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagClose(this); 7110 else return visitor.visitChildren(this); 7111 } 7112 } 7113 7114 public final DtTagCloseContext dtTagClose() throws RecognitionException { 7115 DtTagCloseContext _localctx = new DtTagCloseContext(_ctx, getState()); 7116 enterRule(_localctx, 62, RULE_dtTagClose); 7117 int _la; 7118 try { 7119 enterOuterAlt(_localctx, 1); 7120 { 7121 setState(871); 7122 match(OPEN); 7123 setState(872); 7124 match(SLASH); 7125 setState(873); 7126 match(DT_HTML_TAG_NAME); 7127 setState(877); 7128 _errHandler.sync(this); 7129 _la = _input.LA(1); 7130 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7131 { 7132 { 7133 setState(874); 7134 _la = _input.LA(1); 7135 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7136 _errHandler.recoverInline(this); 7137 } 7138 else { 7139 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 7140 _errHandler.reportMatch(this); 7141 consume(); 7142 } 7143 } 7144 } 7145 setState(879); 7146 _errHandler.sync(this); 7147 _la = _input.LA(1); 7148 } 7149 setState(880); 7150 match(CLOSE); 7151 } 7152 } 7153 catch (RecognitionException re) { 7154 _localctx.exception = re; 7155 _errHandler.reportError(this, re); 7156 _errHandler.recover(this, re); 7157 } 7158 finally { 7159 exitRule(); 7160 } 7161 return _localctx; 7162 } 7163 7164 public static class DtContext extends ParserRuleContext { 7165 public DtTagOpenContext dtTagOpen() { 7166 return getRuleContext(DtTagOpenContext.class,0); 7167 } 7168 public DtTagCloseContext dtTagClose() { 7169 return getRuleContext(DtTagCloseContext.class,0); 7170 } 7171 public List<HtmlTagContext> htmlTag() { 7172 return getRuleContexts(HtmlTagContext.class); 7173 } 7174 public HtmlTagContext htmlTag(int i) { 7175 return getRuleContext(HtmlTagContext.class,i); 7176 } 7177 public List<SingletonTagContext> singletonTag() { 7178 return getRuleContexts(SingletonTagContext.class); 7179 } 7180 public SingletonTagContext singletonTag(int i) { 7181 return getRuleContext(SingletonTagContext.class,i); 7182 } 7183 public List<ParagraphContext> paragraph() { 7184 return getRuleContexts(ParagraphContext.class); 7185 } 7186 public ParagraphContext paragraph(int i) { 7187 return getRuleContext(ParagraphContext.class,i); 7188 } 7189 public List<LiContext> li() { 7190 return getRuleContexts(LiContext.class); 7191 } 7192 public LiContext li(int i) { 7193 return getRuleContext(LiContext.class,i); 7194 } 7195 public List<TrContext> tr() { 7196 return getRuleContexts(TrContext.class); 7197 } 7198 public TrContext tr(int i) { 7199 return getRuleContext(TrContext.class,i); 7200 } 7201 public List<TdContext> td() { 7202 return getRuleContexts(TdContext.class); 7203 } 7204 public TdContext td(int i) { 7205 return getRuleContext(TdContext.class,i); 7206 } 7207 public List<ThContext> th() { 7208 return getRuleContexts(ThContext.class); 7209 } 7210 public ThContext th(int i) { 7211 return getRuleContext(ThContext.class,i); 7212 } 7213 public List<BodyContext> body() { 7214 return getRuleContexts(BodyContext.class); 7215 } 7216 public BodyContext body(int i) { 7217 return getRuleContext(BodyContext.class,i); 7218 } 7219 public List<ColgroupContext> colgroup() { 7220 return getRuleContexts(ColgroupContext.class); 7221 } 7222 public ColgroupContext colgroup(int i) { 7223 return getRuleContext(ColgroupContext.class,i); 7224 } 7225 public List<DdContext> dd() { 7226 return getRuleContexts(DdContext.class); 7227 } 7228 public DdContext dd(int i) { 7229 return getRuleContext(DdContext.class,i); 7230 } 7231 public List<HeadContext> head() { 7232 return getRuleContexts(HeadContext.class); 7233 } 7234 public HeadContext head(int i) { 7235 return getRuleContext(HeadContext.class,i); 7236 } 7237 public List<HtmlContext> html() { 7238 return getRuleContexts(HtmlContext.class); 7239 } 7240 public HtmlContext html(int i) { 7241 return getRuleContext(HtmlContext.class,i); 7242 } 7243 public List<OptionContext> option() { 7244 return getRuleContexts(OptionContext.class); 7245 } 7246 public OptionContext option(int i) { 7247 return getRuleContext(OptionContext.class,i); 7248 } 7249 public List<TbodyContext> tbody() { 7250 return getRuleContexts(TbodyContext.class); 7251 } 7252 public TbodyContext tbody(int i) { 7253 return getRuleContext(TbodyContext.class,i); 7254 } 7255 public List<TheadContext> thead() { 7256 return getRuleContexts(TheadContext.class); 7257 } 7258 public TheadContext thead(int i) { 7259 return getRuleContext(TheadContext.class,i); 7260 } 7261 public List<TfootContext> tfoot() { 7262 return getRuleContexts(TfootContext.class); 7263 } 7264 public TfootContext tfoot(int i) { 7265 return getRuleContext(TfootContext.class,i); 7266 } 7267 public List<PTagOpenContext> pTagOpen() { 7268 return getRuleContexts(PTagOpenContext.class); 7269 } 7270 public PTagOpenContext pTagOpen(int i) { 7271 return getRuleContext(PTagOpenContext.class,i); 7272 } 7273 public List<LiTagOpenContext> liTagOpen() { 7274 return getRuleContexts(LiTagOpenContext.class); 7275 } 7276 public LiTagOpenContext liTagOpen(int i) { 7277 return getRuleContext(LiTagOpenContext.class,i); 7278 } 7279 public List<TrTagOpenContext> trTagOpen() { 7280 return getRuleContexts(TrTagOpenContext.class); 7281 } 7282 public TrTagOpenContext trTagOpen(int i) { 7283 return getRuleContext(TrTagOpenContext.class,i); 7284 } 7285 public List<TdTagOpenContext> tdTagOpen() { 7286 return getRuleContexts(TdTagOpenContext.class); 7287 } 7288 public TdTagOpenContext tdTagOpen(int i) { 7289 return getRuleContext(TdTagOpenContext.class,i); 7290 } 7291 public List<ThTagOpenContext> thTagOpen() { 7292 return getRuleContexts(ThTagOpenContext.class); 7293 } 7294 public ThTagOpenContext thTagOpen(int i) { 7295 return getRuleContext(ThTagOpenContext.class,i); 7296 } 7297 public List<BodyTagOpenContext> bodyTagOpen() { 7298 return getRuleContexts(BodyTagOpenContext.class); 7299 } 7300 public BodyTagOpenContext bodyTagOpen(int i) { 7301 return getRuleContext(BodyTagOpenContext.class,i); 7302 } 7303 public List<ColgroupTagOpenContext> colgroupTagOpen() { 7304 return getRuleContexts(ColgroupTagOpenContext.class); 7305 } 7306 public ColgroupTagOpenContext colgroupTagOpen(int i) { 7307 return getRuleContext(ColgroupTagOpenContext.class,i); 7308 } 7309 public List<DdTagOpenContext> ddTagOpen() { 7310 return getRuleContexts(DdTagOpenContext.class); 7311 } 7312 public DdTagOpenContext ddTagOpen(int i) { 7313 return getRuleContext(DdTagOpenContext.class,i); 7314 } 7315 public List<HeadTagOpenContext> headTagOpen() { 7316 return getRuleContexts(HeadTagOpenContext.class); 7317 } 7318 public HeadTagOpenContext headTagOpen(int i) { 7319 return getRuleContext(HeadTagOpenContext.class,i); 7320 } 7321 public List<HtmlTagOpenContext> htmlTagOpen() { 7322 return getRuleContexts(HtmlTagOpenContext.class); 7323 } 7324 public HtmlTagOpenContext htmlTagOpen(int i) { 7325 return getRuleContext(HtmlTagOpenContext.class,i); 7326 } 7327 public List<OptionTagOpenContext> optionTagOpen() { 7328 return getRuleContexts(OptionTagOpenContext.class); 7329 } 7330 public OptionTagOpenContext optionTagOpen(int i) { 7331 return getRuleContext(OptionTagOpenContext.class,i); 7332 } 7333 public List<TbodyTagOpenContext> tbodyTagOpen() { 7334 return getRuleContexts(TbodyTagOpenContext.class); 7335 } 7336 public TbodyTagOpenContext tbodyTagOpen(int i) { 7337 return getRuleContext(TbodyTagOpenContext.class,i); 7338 } 7339 public List<TheadTagOpenContext> theadTagOpen() { 7340 return getRuleContexts(TheadTagOpenContext.class); 7341 } 7342 public TheadTagOpenContext theadTagOpen(int i) { 7343 return getRuleContext(TheadTagOpenContext.class,i); 7344 } 7345 public List<TfootTagOpenContext> tfootTagOpen() { 7346 return getRuleContexts(TfootTagOpenContext.class); 7347 } 7348 public TfootTagOpenContext tfootTagOpen(int i) { 7349 return getRuleContext(TfootTagOpenContext.class,i); 7350 } 7351 public List<HtmlCommentContext> htmlComment() { 7352 return getRuleContexts(HtmlCommentContext.class); 7353 } 7354 public HtmlCommentContext htmlComment(int i) { 7355 return getRuleContext(HtmlCommentContext.class,i); 7356 } 7357 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 7358 public TerminalNode CDATA(int i) { 7359 return getToken(JavadocParser.CDATA, i); 7360 } 7361 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7362 public TerminalNode NEWLINE(int i) { 7363 return getToken(JavadocParser.NEWLINE, i); 7364 } 7365 public List<TextContext> text() { 7366 return getRuleContexts(TextContext.class); 7367 } 7368 public TextContext text(int i) { 7369 return getRuleContext(TextContext.class,i); 7370 } 7371 public List<JavadocInlineTagContext> javadocInlineTag() { 7372 return getRuleContexts(JavadocInlineTagContext.class); 7373 } 7374 public JavadocInlineTagContext javadocInlineTag(int i) { 7375 return getRuleContext(JavadocInlineTagContext.class,i); 7376 } 7377 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7378 public TerminalNode LEADING_ASTERISK(int i) { 7379 return getToken(JavadocParser.LEADING_ASTERISK, i); 7380 } 7381 public DtContext(ParserRuleContext parent, int invokingState) { 7382 super(parent, invokingState); 7383 } 7384 @Override public int getRuleIndex() { return RULE_dt; } 7385 @Override 7386 public void enterRule(ParseTreeListener listener) { 7387 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDt(this); 7388 } 7389 @Override 7390 public void exitRule(ParseTreeListener listener) { 7391 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDt(this); 7392 } 7393 @Override 7394 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7395 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDt(this); 7396 else return visitor.visitChildren(this); 7397 } 7398 } 7399 7400 public final DtContext dt() throws RecognitionException { 7401 DtContext _localctx = new DtContext(_ctx, getState()); 7402 enterRule(_localctx, 64, RULE_dt); 7403 try { 7404 int _alt; 7405 enterOuterAlt(_localctx, 1); 7406 { 7407 setState(882); 7408 dtTagOpen(); 7409 setState(922); 7410 _errHandler.sync(this); 7411 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 7412 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 7413 if ( _alt==1 ) { 7414 { 7415 setState(920); 7416 _errHandler.sync(this); 7417 switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { 7418 case 1: 7419 { 7420 setState(883); 7421 htmlTag(); 7422 } 7423 break; 7424 case 2: 7425 { 7426 setState(884); 7427 singletonTag(); 7428 } 7429 break; 7430 case 3: 7431 { 7432 setState(885); 7433 paragraph(); 7434 } 7435 break; 7436 case 4: 7437 { 7438 setState(886); 7439 li(); 7440 } 7441 break; 7442 case 5: 7443 { 7444 setState(887); 7445 tr(); 7446 } 7447 break; 7448 case 6: 7449 { 7450 setState(888); 7451 td(); 7452 } 7453 break; 7454 case 7: 7455 { 7456 setState(889); 7457 th(); 7458 } 7459 break; 7460 case 8: 7461 { 7462 setState(890); 7463 body(); 7464 } 7465 break; 7466 case 9: 7467 { 7468 setState(891); 7469 colgroup(); 7470 } 7471 break; 7472 case 10: 7473 { 7474 setState(892); 7475 dd(); 7476 } 7477 break; 7478 case 11: 7479 { 7480 setState(893); 7481 head(); 7482 } 7483 break; 7484 case 12: 7485 { 7486 setState(894); 7487 html(); 7488 } 7489 break; 7490 case 13: 7491 { 7492 setState(895); 7493 option(); 7494 } 7495 break; 7496 case 14: 7497 { 7498 setState(896); 7499 tbody(); 7500 } 7501 break; 7502 case 15: 7503 { 7504 setState(897); 7505 thead(); 7506 } 7507 break; 7508 case 16: 7509 { 7510 setState(898); 7511 tfoot(); 7512 } 7513 break; 7514 case 17: 7515 { 7516 setState(899); 7517 pTagOpen(); 7518 } 7519 break; 7520 case 18: 7521 { 7522 setState(900); 7523 liTagOpen(); 7524 } 7525 break; 7526 case 19: 7527 { 7528 setState(901); 7529 trTagOpen(); 7530 } 7531 break; 7532 case 20: 7533 { 7534 setState(902); 7535 tdTagOpen(); 7536 } 7537 break; 7538 case 21: 7539 { 7540 setState(903); 7541 thTagOpen(); 7542 } 7543 break; 7544 case 22: 7545 { 7546 setState(904); 7547 bodyTagOpen(); 7548 } 7549 break; 7550 case 23: 7551 { 7552 setState(905); 7553 colgroupTagOpen(); 7554 } 7555 break; 7556 case 24: 7557 { 7558 setState(906); 7559 ddTagOpen(); 7560 } 7561 break; 7562 case 25: 7563 { 7564 setState(907); 7565 headTagOpen(); 7566 } 7567 break; 7568 case 26: 7569 { 7570 setState(908); 7571 htmlTagOpen(); 7572 } 7573 break; 7574 case 27: 7575 { 7576 setState(909); 7577 optionTagOpen(); 7578 } 7579 break; 7580 case 28: 7581 { 7582 setState(910); 7583 tbodyTagOpen(); 7584 } 7585 break; 7586 case 29: 7587 { 7588 setState(911); 7589 theadTagOpen(); 7590 } 7591 break; 7592 case 30: 7593 { 7594 setState(912); 7595 tfootTagOpen(); 7596 } 7597 break; 7598 case 31: 7599 { 7600 { 7601 setState(913); 7602 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 7603 setState(914); 7604 match(LEADING_ASTERISK); 7605 } 7606 } 7607 break; 7608 case 32: 7609 { 7610 setState(915); 7611 htmlComment(); 7612 } 7613 break; 7614 case 33: 7615 { 7616 setState(916); 7617 match(CDATA); 7618 } 7619 break; 7620 case 34: 7621 { 7622 setState(917); 7623 match(NEWLINE); 7624 } 7625 break; 7626 case 35: 7627 { 7628 setState(918); 7629 text(); 7630 } 7631 break; 7632 case 36: 7633 { 7634 setState(919); 7635 javadocInlineTag(); 7636 } 7637 break; 7638 } 7639 } 7640 } 7641 setState(924); 7642 _errHandler.sync(this); 7643 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 7644 } 7645 setState(925); 7646 dtTagClose(); 7647 } 7648 } 7649 catch (RecognitionException re) { 7650 _localctx.exception = re; 7651 _errHandler.reportError(this, re); 7652 _errHandler.recover(this, re); 7653 } 7654 finally { 7655 exitRule(); 7656 } 7657 return _localctx; 7658 } 7659 7660 public static class HeadTagOpenContext extends ParserRuleContext { 7661 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7662 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7663 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7664 public List<AttributeContext> attribute() { 7665 return getRuleContexts(AttributeContext.class); 7666 } 7667 public AttributeContext attribute(int i) { 7668 return getRuleContext(AttributeContext.class,i); 7669 } 7670 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7671 public TerminalNode NEWLINE(int i) { 7672 return getToken(JavadocParser.NEWLINE, i); 7673 } 7674 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7675 public TerminalNode LEADING_ASTERISK(int i) { 7676 return getToken(JavadocParser.LEADING_ASTERISK, i); 7677 } 7678 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7679 public TerminalNode WS(int i) { 7680 return getToken(JavadocParser.WS, i); 7681 } 7682 public HeadTagOpenContext(ParserRuleContext parent, int invokingState) { 7683 super(parent, invokingState); 7684 } 7685 @Override public int getRuleIndex() { return RULE_headTagOpen; } 7686 @Override 7687 public void enterRule(ParseTreeListener listener) { 7688 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagOpen(this); 7689 } 7690 @Override 7691 public void exitRule(ParseTreeListener listener) { 7692 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagOpen(this); 7693 } 7694 @Override 7695 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7696 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagOpen(this); 7697 else return visitor.visitChildren(this); 7698 } 7699 } 7700 7701 public final HeadTagOpenContext headTagOpen() throws RecognitionException { 7702 HeadTagOpenContext _localctx = new HeadTagOpenContext(_ctx, getState()); 7703 enterRule(_localctx, 66, RULE_headTagOpen); 7704 int _la; 7705 try { 7706 enterOuterAlt(_localctx, 1); 7707 { 7708 setState(927); 7709 match(OPEN); 7710 setState(928); 7711 match(HEAD_HTML_TAG_NAME); 7712 setState(935); 7713 _errHandler.sync(this); 7714 _la = _input.LA(1); 7715 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 7716 { 7717 setState(933); 7718 _errHandler.sync(this); 7719 switch (_input.LA(1)) { 7720 case HTML_TAG_NAME: 7721 { 7722 setState(929); 7723 attribute(); 7724 } 7725 break; 7726 case NEWLINE: 7727 { 7728 setState(930); 7729 match(NEWLINE); 7730 } 7731 break; 7732 case LEADING_ASTERISK: 7733 { 7734 setState(931); 7735 match(LEADING_ASTERISK); 7736 } 7737 break; 7738 case WS: 7739 { 7740 setState(932); 7741 match(WS); 7742 } 7743 break; 7744 default: 7745 throw new NoViableAltException(this); 7746 } 7747 } 7748 setState(937); 7749 _errHandler.sync(this); 7750 _la = _input.LA(1); 7751 } 7752 setState(938); 7753 match(CLOSE); 7754 } 7755 } 7756 catch (RecognitionException re) { 7757 _localctx.exception = re; 7758 _errHandler.reportError(this, re); 7759 _errHandler.recover(this, re); 7760 } 7761 finally { 7762 exitRule(); 7763 } 7764 return _localctx; 7765 } 7766 7767 public static class HeadTagCloseContext extends ParserRuleContext { 7768 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7769 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7770 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7771 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7772 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7773 public TerminalNode NEWLINE(int i) { 7774 return getToken(JavadocParser.NEWLINE, i); 7775 } 7776 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7777 public TerminalNode LEADING_ASTERISK(int i) { 7778 return getToken(JavadocParser.LEADING_ASTERISK, i); 7779 } 7780 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7781 public TerminalNode WS(int i) { 7782 return getToken(JavadocParser.WS, i); 7783 } 7784 public HeadTagCloseContext(ParserRuleContext parent, int invokingState) { 7785 super(parent, invokingState); 7786 } 7787 @Override public int getRuleIndex() { return RULE_headTagClose; } 7788 @Override 7789 public void enterRule(ParseTreeListener listener) { 7790 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagClose(this); 7791 } 7792 @Override 7793 public void exitRule(ParseTreeListener listener) { 7794 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagClose(this); 7795 } 7796 @Override 7797 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7798 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagClose(this); 7799 else return visitor.visitChildren(this); 7800 } 7801 } 7802 7803 public final HeadTagCloseContext headTagClose() throws RecognitionException { 7804 HeadTagCloseContext _localctx = new HeadTagCloseContext(_ctx, getState()); 7805 enterRule(_localctx, 68, RULE_headTagClose); 7806 int _la; 7807 try { 7808 enterOuterAlt(_localctx, 1); 7809 { 7810 setState(940); 7811 match(OPEN); 7812 setState(941); 7813 match(SLASH); 7814 setState(942); 7815 match(HEAD_HTML_TAG_NAME); 7816 setState(946); 7817 _errHandler.sync(this); 7818 _la = _input.LA(1); 7819 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7820 { 7821 { 7822 setState(943); 7823 _la = _input.LA(1); 7824 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7825 _errHandler.recoverInline(this); 7826 } 7827 else { 7828 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 7829 _errHandler.reportMatch(this); 7830 consume(); 7831 } 7832 } 7833 } 7834 setState(948); 7835 _errHandler.sync(this); 7836 _la = _input.LA(1); 7837 } 7838 setState(949); 7839 match(CLOSE); 7840 } 7841 } 7842 catch (RecognitionException re) { 7843 _localctx.exception = re; 7844 _errHandler.reportError(this, re); 7845 _errHandler.recover(this, re); 7846 } 7847 finally { 7848 exitRule(); 7849 } 7850 return _localctx; 7851 } 7852 7853 public static class HeadContext extends ParserRuleContext { 7854 public HeadTagOpenContext headTagOpen() { 7855 return getRuleContext(HeadTagOpenContext.class,0); 7856 } 7857 public HeadTagCloseContext headTagClose() { 7858 return getRuleContext(HeadTagCloseContext.class,0); 7859 } 7860 public List<HtmlTagContext> htmlTag() { 7861 return getRuleContexts(HtmlTagContext.class); 7862 } 7863 public HtmlTagContext htmlTag(int i) { 7864 return getRuleContext(HtmlTagContext.class,i); 7865 } 7866 public List<SingletonTagContext> singletonTag() { 7867 return getRuleContexts(SingletonTagContext.class); 7868 } 7869 public SingletonTagContext singletonTag(int i) { 7870 return getRuleContext(SingletonTagContext.class,i); 7871 } 7872 public List<ParagraphContext> paragraph() { 7873 return getRuleContexts(ParagraphContext.class); 7874 } 7875 public ParagraphContext paragraph(int i) { 7876 return getRuleContext(ParagraphContext.class,i); 7877 } 7878 public List<LiContext> li() { 7879 return getRuleContexts(LiContext.class); 7880 } 7881 public LiContext li(int i) { 7882 return getRuleContext(LiContext.class,i); 7883 } 7884 public List<TrContext> tr() { 7885 return getRuleContexts(TrContext.class); 7886 } 7887 public TrContext tr(int i) { 7888 return getRuleContext(TrContext.class,i); 7889 } 7890 public List<TdContext> td() { 7891 return getRuleContexts(TdContext.class); 7892 } 7893 public TdContext td(int i) { 7894 return getRuleContext(TdContext.class,i); 7895 } 7896 public List<ThContext> th() { 7897 return getRuleContexts(ThContext.class); 7898 } 7899 public ThContext th(int i) { 7900 return getRuleContext(ThContext.class,i); 7901 } 7902 public List<BodyContext> body() { 7903 return getRuleContexts(BodyContext.class); 7904 } 7905 public BodyContext body(int i) { 7906 return getRuleContext(BodyContext.class,i); 7907 } 7908 public List<ColgroupContext> colgroup() { 7909 return getRuleContexts(ColgroupContext.class); 7910 } 7911 public ColgroupContext colgroup(int i) { 7912 return getRuleContext(ColgroupContext.class,i); 7913 } 7914 public List<DdContext> dd() { 7915 return getRuleContexts(DdContext.class); 7916 } 7917 public DdContext dd(int i) { 7918 return getRuleContext(DdContext.class,i); 7919 } 7920 public List<DtContext> dt() { 7921 return getRuleContexts(DtContext.class); 7922 } 7923 public DtContext dt(int i) { 7924 return getRuleContext(DtContext.class,i); 7925 } 7926 public List<HtmlContext> html() { 7927 return getRuleContexts(HtmlContext.class); 7928 } 7929 public HtmlContext html(int i) { 7930 return getRuleContext(HtmlContext.class,i); 7931 } 7932 public List<OptionContext> option() { 7933 return getRuleContexts(OptionContext.class); 7934 } 7935 public OptionContext option(int i) { 7936 return getRuleContext(OptionContext.class,i); 7937 } 7938 public List<TbodyContext> tbody() { 7939 return getRuleContexts(TbodyContext.class); 7940 } 7941 public TbodyContext tbody(int i) { 7942 return getRuleContext(TbodyContext.class,i); 7943 } 7944 public List<TheadContext> thead() { 7945 return getRuleContexts(TheadContext.class); 7946 } 7947 public TheadContext thead(int i) { 7948 return getRuleContext(TheadContext.class,i); 7949 } 7950 public List<TfootContext> tfoot() { 7951 return getRuleContexts(TfootContext.class); 7952 } 7953 public TfootContext tfoot(int i) { 7954 return getRuleContext(TfootContext.class,i); 7955 } 7956 public List<PTagOpenContext> pTagOpen() { 7957 return getRuleContexts(PTagOpenContext.class); 7958 } 7959 public PTagOpenContext pTagOpen(int i) { 7960 return getRuleContext(PTagOpenContext.class,i); 7961 } 7962 public List<LiTagOpenContext> liTagOpen() { 7963 return getRuleContexts(LiTagOpenContext.class); 7964 } 7965 public LiTagOpenContext liTagOpen(int i) { 7966 return getRuleContext(LiTagOpenContext.class,i); 7967 } 7968 public List<TrTagOpenContext> trTagOpen() { 7969 return getRuleContexts(TrTagOpenContext.class); 7970 } 7971 public TrTagOpenContext trTagOpen(int i) { 7972 return getRuleContext(TrTagOpenContext.class,i); 7973 } 7974 public List<TdTagOpenContext> tdTagOpen() { 7975 return getRuleContexts(TdTagOpenContext.class); 7976 } 7977 public TdTagOpenContext tdTagOpen(int i) { 7978 return getRuleContext(TdTagOpenContext.class,i); 7979 } 7980 public List<ThTagOpenContext> thTagOpen() { 7981 return getRuleContexts(ThTagOpenContext.class); 7982 } 7983 public ThTagOpenContext thTagOpen(int i) { 7984 return getRuleContext(ThTagOpenContext.class,i); 7985 } 7986 public List<BodyTagOpenContext> bodyTagOpen() { 7987 return getRuleContexts(BodyTagOpenContext.class); 7988 } 7989 public BodyTagOpenContext bodyTagOpen(int i) { 7990 return getRuleContext(BodyTagOpenContext.class,i); 7991 } 7992 public List<ColgroupTagOpenContext> colgroupTagOpen() { 7993 return getRuleContexts(ColgroupTagOpenContext.class); 7994 } 7995 public ColgroupTagOpenContext colgroupTagOpen(int i) { 7996 return getRuleContext(ColgroupTagOpenContext.class,i); 7997 } 7998 public List<DdTagOpenContext> ddTagOpen() { 7999 return getRuleContexts(DdTagOpenContext.class); 8000 } 8001 public DdTagOpenContext ddTagOpen(int i) { 8002 return getRuleContext(DdTagOpenContext.class,i); 8003 } 8004 public List<DtTagOpenContext> dtTagOpen() { 8005 return getRuleContexts(DtTagOpenContext.class); 8006 } 8007 public DtTagOpenContext dtTagOpen(int i) { 8008 return getRuleContext(DtTagOpenContext.class,i); 8009 } 8010 public List<HtmlTagOpenContext> htmlTagOpen() { 8011 return getRuleContexts(HtmlTagOpenContext.class); 8012 } 8013 public HtmlTagOpenContext htmlTagOpen(int i) { 8014 return getRuleContext(HtmlTagOpenContext.class,i); 8015 } 8016 public List<OptionTagOpenContext> optionTagOpen() { 8017 return getRuleContexts(OptionTagOpenContext.class); 8018 } 8019 public OptionTagOpenContext optionTagOpen(int i) { 8020 return getRuleContext(OptionTagOpenContext.class,i); 8021 } 8022 public List<TbodyTagOpenContext> tbodyTagOpen() { 8023 return getRuleContexts(TbodyTagOpenContext.class); 8024 } 8025 public TbodyTagOpenContext tbodyTagOpen(int i) { 8026 return getRuleContext(TbodyTagOpenContext.class,i); 8027 } 8028 public List<TheadTagOpenContext> theadTagOpen() { 8029 return getRuleContexts(TheadTagOpenContext.class); 8030 } 8031 public TheadTagOpenContext theadTagOpen(int i) { 8032 return getRuleContext(TheadTagOpenContext.class,i); 8033 } 8034 public List<TfootTagOpenContext> tfootTagOpen() { 8035 return getRuleContexts(TfootTagOpenContext.class); 8036 } 8037 public TfootTagOpenContext tfootTagOpen(int i) { 8038 return getRuleContext(TfootTagOpenContext.class,i); 8039 } 8040 public List<HtmlCommentContext> htmlComment() { 8041 return getRuleContexts(HtmlCommentContext.class); 8042 } 8043 public HtmlCommentContext htmlComment(int i) { 8044 return getRuleContext(HtmlCommentContext.class,i); 8045 } 8046 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8047 public TerminalNode CDATA(int i) { 8048 return getToken(JavadocParser.CDATA, i); 8049 } 8050 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8051 public TerminalNode NEWLINE(int i) { 8052 return getToken(JavadocParser.NEWLINE, i); 8053 } 8054 public List<TextContext> text() { 8055 return getRuleContexts(TextContext.class); 8056 } 8057 public TextContext text(int i) { 8058 return getRuleContext(TextContext.class,i); 8059 } 8060 public List<JavadocInlineTagContext> javadocInlineTag() { 8061 return getRuleContexts(JavadocInlineTagContext.class); 8062 } 8063 public JavadocInlineTagContext javadocInlineTag(int i) { 8064 return getRuleContext(JavadocInlineTagContext.class,i); 8065 } 8066 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8067 public TerminalNode LEADING_ASTERISK(int i) { 8068 return getToken(JavadocParser.LEADING_ASTERISK, i); 8069 } 8070 public HeadContext(ParserRuleContext parent, int invokingState) { 8071 super(parent, invokingState); 8072 } 8073 @Override public int getRuleIndex() { return RULE_head; } 8074 @Override 8075 public void enterRule(ParseTreeListener listener) { 8076 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHead(this); 8077 } 8078 @Override 8079 public void exitRule(ParseTreeListener listener) { 8080 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHead(this); 8081 } 8082 @Override 8083 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8084 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHead(this); 8085 else return visitor.visitChildren(this); 8086 } 8087 } 8088 8089 public final HeadContext head() throws RecognitionException { 8090 HeadContext _localctx = new HeadContext(_ctx, getState()); 8091 enterRule(_localctx, 70, RULE_head); 8092 try { 8093 int _alt; 8094 enterOuterAlt(_localctx, 1); 8095 { 8096 setState(951); 8097 headTagOpen(); 8098 setState(991); 8099 _errHandler.sync(this); 8100 _alt = getInterpreter().adaptivePredict(_input,66,_ctx); 8101 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8102 if ( _alt==1 ) { 8103 { 8104 setState(989); 8105 _errHandler.sync(this); 8106 switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) { 8107 case 1: 8108 { 8109 setState(952); 8110 htmlTag(); 8111 } 8112 break; 8113 case 2: 8114 { 8115 setState(953); 8116 singletonTag(); 8117 } 8118 break; 8119 case 3: 8120 { 8121 setState(954); 8122 paragraph(); 8123 } 8124 break; 8125 case 4: 8126 { 8127 setState(955); 8128 li(); 8129 } 8130 break; 8131 case 5: 8132 { 8133 setState(956); 8134 tr(); 8135 } 8136 break; 8137 case 6: 8138 { 8139 setState(957); 8140 td(); 8141 } 8142 break; 8143 case 7: 8144 { 8145 setState(958); 8146 th(); 8147 } 8148 break; 8149 case 8: 8150 { 8151 setState(959); 8152 body(); 8153 } 8154 break; 8155 case 9: 8156 { 8157 setState(960); 8158 colgroup(); 8159 } 8160 break; 8161 case 10: 8162 { 8163 setState(961); 8164 dd(); 8165 } 8166 break; 8167 case 11: 8168 { 8169 setState(962); 8170 dt(); 8171 } 8172 break; 8173 case 12: 8174 { 8175 setState(963); 8176 html(); 8177 } 8178 break; 8179 case 13: 8180 { 8181 setState(964); 8182 option(); 8183 } 8184 break; 8185 case 14: 8186 { 8187 setState(965); 8188 tbody(); 8189 } 8190 break; 8191 case 15: 8192 { 8193 setState(966); 8194 thead(); 8195 } 8196 break; 8197 case 16: 8198 { 8199 setState(967); 8200 tfoot(); 8201 } 8202 break; 8203 case 17: 8204 { 8205 setState(968); 8206 pTagOpen(); 8207 } 8208 break; 8209 case 18: 8210 { 8211 setState(969); 8212 liTagOpen(); 8213 } 8214 break; 8215 case 19: 8216 { 8217 setState(970); 8218 trTagOpen(); 8219 } 8220 break; 8221 case 20: 8222 { 8223 setState(971); 8224 tdTagOpen(); 8225 } 8226 break; 8227 case 21: 8228 { 8229 setState(972); 8230 thTagOpen(); 8231 } 8232 break; 8233 case 22: 8234 { 8235 setState(973); 8236 bodyTagOpen(); 8237 } 8238 break; 8239 case 23: 8240 { 8241 setState(974); 8242 colgroupTagOpen(); 8243 } 8244 break; 8245 case 24: 8246 { 8247 setState(975); 8248 ddTagOpen(); 8249 } 8250 break; 8251 case 25: 8252 { 8253 setState(976); 8254 dtTagOpen(); 8255 } 8256 break; 8257 case 26: 8258 { 8259 setState(977); 8260 htmlTagOpen(); 8261 } 8262 break; 8263 case 27: 8264 { 8265 setState(978); 8266 optionTagOpen(); 8267 } 8268 break; 8269 case 28: 8270 { 8271 setState(979); 8272 tbodyTagOpen(); 8273 } 8274 break; 8275 case 29: 8276 { 8277 setState(980); 8278 theadTagOpen(); 8279 } 8280 break; 8281 case 30: 8282 { 8283 setState(981); 8284 tfootTagOpen(); 8285 } 8286 break; 8287 case 31: 8288 { 8289 { 8290 setState(982); 8291 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8292 setState(983); 8293 match(LEADING_ASTERISK); 8294 } 8295 } 8296 break; 8297 case 32: 8298 { 8299 setState(984); 8300 htmlComment(); 8301 } 8302 break; 8303 case 33: 8304 { 8305 setState(985); 8306 match(CDATA); 8307 } 8308 break; 8309 case 34: 8310 { 8311 setState(986); 8312 match(NEWLINE); 8313 } 8314 break; 8315 case 35: 8316 { 8317 setState(987); 8318 text(); 8319 } 8320 break; 8321 case 36: 8322 { 8323 setState(988); 8324 javadocInlineTag(); 8325 } 8326 break; 8327 } 8328 } 8329 } 8330 setState(993); 8331 _errHandler.sync(this); 8332 _alt = getInterpreter().adaptivePredict(_input,66,_ctx); 8333 } 8334 setState(994); 8335 headTagClose(); 8336 } 8337 } 8338 catch (RecognitionException re) { 8339 _localctx.exception = re; 8340 _errHandler.reportError(this, re); 8341 _errHandler.recover(this, re); 8342 } 8343 finally { 8344 exitRule(); 8345 } 8346 return _localctx; 8347 } 8348 8349 public static class HtmlTagOpenContext extends ParserRuleContext { 8350 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8351 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 8352 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8353 public List<AttributeContext> attribute() { 8354 return getRuleContexts(AttributeContext.class); 8355 } 8356 public AttributeContext attribute(int i) { 8357 return getRuleContext(AttributeContext.class,i); 8358 } 8359 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8360 public TerminalNode NEWLINE(int i) { 8361 return getToken(JavadocParser.NEWLINE, i); 8362 } 8363 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8364 public TerminalNode LEADING_ASTERISK(int i) { 8365 return getToken(JavadocParser.LEADING_ASTERISK, i); 8366 } 8367 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8368 public TerminalNode WS(int i) { 8369 return getToken(JavadocParser.WS, i); 8370 } 8371 public HtmlTagOpenContext(ParserRuleContext parent, int invokingState) { 8372 super(parent, invokingState); 8373 } 8374 @Override public int getRuleIndex() { return RULE_htmlTagOpen; } 8375 @Override 8376 public void enterRule(ParseTreeListener listener) { 8377 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagOpen(this); 8378 } 8379 @Override 8380 public void exitRule(ParseTreeListener listener) { 8381 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagOpen(this); 8382 } 8383 @Override 8384 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8385 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagOpen(this); 8386 else return visitor.visitChildren(this); 8387 } 8388 } 8389 8390 public final HtmlTagOpenContext htmlTagOpen() throws RecognitionException { 8391 HtmlTagOpenContext _localctx = new HtmlTagOpenContext(_ctx, getState()); 8392 enterRule(_localctx, 72, RULE_htmlTagOpen); 8393 int _la; 8394 try { 8395 enterOuterAlt(_localctx, 1); 8396 { 8397 setState(996); 8398 match(OPEN); 8399 setState(997); 8400 match(HTML_HTML_TAG_NAME); 8401 setState(1004); 8402 _errHandler.sync(this); 8403 _la = _input.LA(1); 8404 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 8405 { 8406 setState(1002); 8407 _errHandler.sync(this); 8408 switch (_input.LA(1)) { 8409 case HTML_TAG_NAME: 8410 { 8411 setState(998); 8412 attribute(); 8413 } 8414 break; 8415 case NEWLINE: 8416 { 8417 setState(999); 8418 match(NEWLINE); 8419 } 8420 break; 8421 case LEADING_ASTERISK: 8422 { 8423 setState(1000); 8424 match(LEADING_ASTERISK); 8425 } 8426 break; 8427 case WS: 8428 { 8429 setState(1001); 8430 match(WS); 8431 } 8432 break; 8433 default: 8434 throw new NoViableAltException(this); 8435 } 8436 } 8437 setState(1006); 8438 _errHandler.sync(this); 8439 _la = _input.LA(1); 8440 } 8441 setState(1007); 8442 match(CLOSE); 8443 } 8444 } 8445 catch (RecognitionException re) { 8446 _localctx.exception = re; 8447 _errHandler.reportError(this, re); 8448 _errHandler.recover(this, re); 8449 } 8450 finally { 8451 exitRule(); 8452 } 8453 return _localctx; 8454 } 8455 8456 public static class HtmlTagCloseContext extends ParserRuleContext { 8457 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8458 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 8459 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 8460 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8461 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8462 public TerminalNode NEWLINE(int i) { 8463 return getToken(JavadocParser.NEWLINE, i); 8464 } 8465 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8466 public TerminalNode LEADING_ASTERISK(int i) { 8467 return getToken(JavadocParser.LEADING_ASTERISK, i); 8468 } 8469 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8470 public TerminalNode WS(int i) { 8471 return getToken(JavadocParser.WS, i); 8472 } 8473 public HtmlTagCloseContext(ParserRuleContext parent, int invokingState) { 8474 super(parent, invokingState); 8475 } 8476 @Override public int getRuleIndex() { return RULE_htmlTagClose; } 8477 @Override 8478 public void enterRule(ParseTreeListener listener) { 8479 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagClose(this); 8480 } 8481 @Override 8482 public void exitRule(ParseTreeListener listener) { 8483 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagClose(this); 8484 } 8485 @Override 8486 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8487 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagClose(this); 8488 else return visitor.visitChildren(this); 8489 } 8490 } 8491 8492 public final HtmlTagCloseContext htmlTagClose() throws RecognitionException { 8493 HtmlTagCloseContext _localctx = new HtmlTagCloseContext(_ctx, getState()); 8494 enterRule(_localctx, 74, RULE_htmlTagClose); 8495 int _la; 8496 try { 8497 enterOuterAlt(_localctx, 1); 8498 { 8499 setState(1009); 8500 match(OPEN); 8501 setState(1010); 8502 match(SLASH); 8503 setState(1011); 8504 match(HTML_HTML_TAG_NAME); 8505 setState(1015); 8506 _errHandler.sync(this); 8507 _la = _input.LA(1); 8508 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 8509 { 8510 { 8511 setState(1012); 8512 _la = _input.LA(1); 8513 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 8514 _errHandler.recoverInline(this); 8515 } 8516 else { 8517 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 8518 _errHandler.reportMatch(this); 8519 consume(); 8520 } 8521 } 8522 } 8523 setState(1017); 8524 _errHandler.sync(this); 8525 _la = _input.LA(1); 8526 } 8527 setState(1018); 8528 match(CLOSE); 8529 } 8530 } 8531 catch (RecognitionException re) { 8532 _localctx.exception = re; 8533 _errHandler.reportError(this, re); 8534 _errHandler.recover(this, re); 8535 } 8536 finally { 8537 exitRule(); 8538 } 8539 return _localctx; 8540 } 8541 8542 public static class HtmlContext extends ParserRuleContext { 8543 public HtmlTagOpenContext htmlTagOpen() { 8544 return getRuleContext(HtmlTagOpenContext.class,0); 8545 } 8546 public HtmlTagCloseContext htmlTagClose() { 8547 return getRuleContext(HtmlTagCloseContext.class,0); 8548 } 8549 public List<HtmlTagContext> htmlTag() { 8550 return getRuleContexts(HtmlTagContext.class); 8551 } 8552 public HtmlTagContext htmlTag(int i) { 8553 return getRuleContext(HtmlTagContext.class,i); 8554 } 8555 public List<SingletonTagContext> singletonTag() { 8556 return getRuleContexts(SingletonTagContext.class); 8557 } 8558 public SingletonTagContext singletonTag(int i) { 8559 return getRuleContext(SingletonTagContext.class,i); 8560 } 8561 public List<ParagraphContext> paragraph() { 8562 return getRuleContexts(ParagraphContext.class); 8563 } 8564 public ParagraphContext paragraph(int i) { 8565 return getRuleContext(ParagraphContext.class,i); 8566 } 8567 public List<LiContext> li() { 8568 return getRuleContexts(LiContext.class); 8569 } 8570 public LiContext li(int i) { 8571 return getRuleContext(LiContext.class,i); 8572 } 8573 public List<TrContext> tr() { 8574 return getRuleContexts(TrContext.class); 8575 } 8576 public TrContext tr(int i) { 8577 return getRuleContext(TrContext.class,i); 8578 } 8579 public List<TdContext> td() { 8580 return getRuleContexts(TdContext.class); 8581 } 8582 public TdContext td(int i) { 8583 return getRuleContext(TdContext.class,i); 8584 } 8585 public List<ThContext> th() { 8586 return getRuleContexts(ThContext.class); 8587 } 8588 public ThContext th(int i) { 8589 return getRuleContext(ThContext.class,i); 8590 } 8591 public List<BodyContext> body() { 8592 return getRuleContexts(BodyContext.class); 8593 } 8594 public BodyContext body(int i) { 8595 return getRuleContext(BodyContext.class,i); 8596 } 8597 public List<ColgroupContext> colgroup() { 8598 return getRuleContexts(ColgroupContext.class); 8599 } 8600 public ColgroupContext colgroup(int i) { 8601 return getRuleContext(ColgroupContext.class,i); 8602 } 8603 public List<DdContext> dd() { 8604 return getRuleContexts(DdContext.class); 8605 } 8606 public DdContext dd(int i) { 8607 return getRuleContext(DdContext.class,i); 8608 } 8609 public List<DtContext> dt() { 8610 return getRuleContexts(DtContext.class); 8611 } 8612 public DtContext dt(int i) { 8613 return getRuleContext(DtContext.class,i); 8614 } 8615 public List<HeadContext> head() { 8616 return getRuleContexts(HeadContext.class); 8617 } 8618 public HeadContext head(int i) { 8619 return getRuleContext(HeadContext.class,i); 8620 } 8621 public List<OptionContext> option() { 8622 return getRuleContexts(OptionContext.class); 8623 } 8624 public OptionContext option(int i) { 8625 return getRuleContext(OptionContext.class,i); 8626 } 8627 public List<TbodyContext> tbody() { 8628 return getRuleContexts(TbodyContext.class); 8629 } 8630 public TbodyContext tbody(int i) { 8631 return getRuleContext(TbodyContext.class,i); 8632 } 8633 public List<TheadContext> thead() { 8634 return getRuleContexts(TheadContext.class); 8635 } 8636 public TheadContext thead(int i) { 8637 return getRuleContext(TheadContext.class,i); 8638 } 8639 public List<TfootContext> tfoot() { 8640 return getRuleContexts(TfootContext.class); 8641 } 8642 public TfootContext tfoot(int i) { 8643 return getRuleContext(TfootContext.class,i); 8644 } 8645 public List<PTagOpenContext> pTagOpen() { 8646 return getRuleContexts(PTagOpenContext.class); 8647 } 8648 public PTagOpenContext pTagOpen(int i) { 8649 return getRuleContext(PTagOpenContext.class,i); 8650 } 8651 public List<LiTagOpenContext> liTagOpen() { 8652 return getRuleContexts(LiTagOpenContext.class); 8653 } 8654 public LiTagOpenContext liTagOpen(int i) { 8655 return getRuleContext(LiTagOpenContext.class,i); 8656 } 8657 public List<TrTagOpenContext> trTagOpen() { 8658 return getRuleContexts(TrTagOpenContext.class); 8659 } 8660 public TrTagOpenContext trTagOpen(int i) { 8661 return getRuleContext(TrTagOpenContext.class,i); 8662 } 8663 public List<TdTagOpenContext> tdTagOpen() { 8664 return getRuleContexts(TdTagOpenContext.class); 8665 } 8666 public TdTagOpenContext tdTagOpen(int i) { 8667 return getRuleContext(TdTagOpenContext.class,i); 8668 } 8669 public List<ThTagOpenContext> thTagOpen() { 8670 return getRuleContexts(ThTagOpenContext.class); 8671 } 8672 public ThTagOpenContext thTagOpen(int i) { 8673 return getRuleContext(ThTagOpenContext.class,i); 8674 } 8675 public List<BodyTagOpenContext> bodyTagOpen() { 8676 return getRuleContexts(BodyTagOpenContext.class); 8677 } 8678 public BodyTagOpenContext bodyTagOpen(int i) { 8679 return getRuleContext(BodyTagOpenContext.class,i); 8680 } 8681 public List<ColgroupTagOpenContext> colgroupTagOpen() { 8682 return getRuleContexts(ColgroupTagOpenContext.class); 8683 } 8684 public ColgroupTagOpenContext colgroupTagOpen(int i) { 8685 return getRuleContext(ColgroupTagOpenContext.class,i); 8686 } 8687 public List<DdTagOpenContext> ddTagOpen() { 8688 return getRuleContexts(DdTagOpenContext.class); 8689 } 8690 public DdTagOpenContext ddTagOpen(int i) { 8691 return getRuleContext(DdTagOpenContext.class,i); 8692 } 8693 public List<DtTagOpenContext> dtTagOpen() { 8694 return getRuleContexts(DtTagOpenContext.class); 8695 } 8696 public DtTagOpenContext dtTagOpen(int i) { 8697 return getRuleContext(DtTagOpenContext.class,i); 8698 } 8699 public List<HeadTagOpenContext> headTagOpen() { 8700 return getRuleContexts(HeadTagOpenContext.class); 8701 } 8702 public HeadTagOpenContext headTagOpen(int i) { 8703 return getRuleContext(HeadTagOpenContext.class,i); 8704 } 8705 public List<OptionTagOpenContext> optionTagOpen() { 8706 return getRuleContexts(OptionTagOpenContext.class); 8707 } 8708 public OptionTagOpenContext optionTagOpen(int i) { 8709 return getRuleContext(OptionTagOpenContext.class,i); 8710 } 8711 public List<TbodyTagOpenContext> tbodyTagOpen() { 8712 return getRuleContexts(TbodyTagOpenContext.class); 8713 } 8714 public TbodyTagOpenContext tbodyTagOpen(int i) { 8715 return getRuleContext(TbodyTagOpenContext.class,i); 8716 } 8717 public List<TheadTagOpenContext> theadTagOpen() { 8718 return getRuleContexts(TheadTagOpenContext.class); 8719 } 8720 public TheadTagOpenContext theadTagOpen(int i) { 8721 return getRuleContext(TheadTagOpenContext.class,i); 8722 } 8723 public List<TfootTagOpenContext> tfootTagOpen() { 8724 return getRuleContexts(TfootTagOpenContext.class); 8725 } 8726 public TfootTagOpenContext tfootTagOpen(int i) { 8727 return getRuleContext(TfootTagOpenContext.class,i); 8728 } 8729 public List<HtmlCommentContext> htmlComment() { 8730 return getRuleContexts(HtmlCommentContext.class); 8731 } 8732 public HtmlCommentContext htmlComment(int i) { 8733 return getRuleContext(HtmlCommentContext.class,i); 8734 } 8735 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8736 public TerminalNode CDATA(int i) { 8737 return getToken(JavadocParser.CDATA, i); 8738 } 8739 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8740 public TerminalNode NEWLINE(int i) { 8741 return getToken(JavadocParser.NEWLINE, i); 8742 } 8743 public List<TextContext> text() { 8744 return getRuleContexts(TextContext.class); 8745 } 8746 public TextContext text(int i) { 8747 return getRuleContext(TextContext.class,i); 8748 } 8749 public List<JavadocInlineTagContext> javadocInlineTag() { 8750 return getRuleContexts(JavadocInlineTagContext.class); 8751 } 8752 public JavadocInlineTagContext javadocInlineTag(int i) { 8753 return getRuleContext(JavadocInlineTagContext.class,i); 8754 } 8755 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8756 public TerminalNode LEADING_ASTERISK(int i) { 8757 return getToken(JavadocParser.LEADING_ASTERISK, i); 8758 } 8759 public HtmlContext(ParserRuleContext parent, int invokingState) { 8760 super(parent, invokingState); 8761 } 8762 @Override public int getRuleIndex() { return RULE_html; } 8763 @Override 8764 public void enterRule(ParseTreeListener listener) { 8765 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtml(this); 8766 } 8767 @Override 8768 public void exitRule(ParseTreeListener listener) { 8769 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtml(this); 8770 } 8771 @Override 8772 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8773 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtml(this); 8774 else return visitor.visitChildren(this); 8775 } 8776 } 8777 8778 public final HtmlContext html() throws RecognitionException { 8779 HtmlContext _localctx = new HtmlContext(_ctx, getState()); 8780 enterRule(_localctx, 76, RULE_html); 8781 try { 8782 int _alt; 8783 enterOuterAlt(_localctx, 1); 8784 { 8785 setState(1020); 8786 htmlTagOpen(); 8787 setState(1060); 8788 _errHandler.sync(this); 8789 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 8790 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8791 if ( _alt==1 ) { 8792 { 8793 setState(1058); 8794 _errHandler.sync(this); 8795 switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { 8796 case 1: 8797 { 8798 setState(1021); 8799 htmlTag(); 8800 } 8801 break; 8802 case 2: 8803 { 8804 setState(1022); 8805 singletonTag(); 8806 } 8807 break; 8808 case 3: 8809 { 8810 setState(1023); 8811 paragraph(); 8812 } 8813 break; 8814 case 4: 8815 { 8816 setState(1024); 8817 li(); 8818 } 8819 break; 8820 case 5: 8821 { 8822 setState(1025); 8823 tr(); 8824 } 8825 break; 8826 case 6: 8827 { 8828 setState(1026); 8829 td(); 8830 } 8831 break; 8832 case 7: 8833 { 8834 setState(1027); 8835 th(); 8836 } 8837 break; 8838 case 8: 8839 { 8840 setState(1028); 8841 body(); 8842 } 8843 break; 8844 case 9: 8845 { 8846 setState(1029); 8847 colgroup(); 8848 } 8849 break; 8850 case 10: 8851 { 8852 setState(1030); 8853 dd(); 8854 } 8855 break; 8856 case 11: 8857 { 8858 setState(1031); 8859 dt(); 8860 } 8861 break; 8862 case 12: 8863 { 8864 setState(1032); 8865 head(); 8866 } 8867 break; 8868 case 13: 8869 { 8870 setState(1033); 8871 option(); 8872 } 8873 break; 8874 case 14: 8875 { 8876 setState(1034); 8877 tbody(); 8878 } 8879 break; 8880 case 15: 8881 { 8882 setState(1035); 8883 thead(); 8884 } 8885 break; 8886 case 16: 8887 { 8888 setState(1036); 8889 tfoot(); 8890 } 8891 break; 8892 case 17: 8893 { 8894 setState(1037); 8895 pTagOpen(); 8896 } 8897 break; 8898 case 18: 8899 { 8900 setState(1038); 8901 liTagOpen(); 8902 } 8903 break; 8904 case 19: 8905 { 8906 setState(1039); 8907 trTagOpen(); 8908 } 8909 break; 8910 case 20: 8911 { 8912 setState(1040); 8913 tdTagOpen(); 8914 } 8915 break; 8916 case 21: 8917 { 8918 setState(1041); 8919 thTagOpen(); 8920 } 8921 break; 8922 case 22: 8923 { 8924 setState(1042); 8925 bodyTagOpen(); 8926 } 8927 break; 8928 case 23: 8929 { 8930 setState(1043); 8931 colgroupTagOpen(); 8932 } 8933 break; 8934 case 24: 8935 { 8936 setState(1044); 8937 ddTagOpen(); 8938 } 8939 break; 8940 case 25: 8941 { 8942 setState(1045); 8943 dtTagOpen(); 8944 } 8945 break; 8946 case 26: 8947 { 8948 setState(1046); 8949 headTagOpen(); 8950 } 8951 break; 8952 case 27: 8953 { 8954 setState(1047); 8955 optionTagOpen(); 8956 } 8957 break; 8958 case 28: 8959 { 8960 setState(1048); 8961 tbodyTagOpen(); 8962 } 8963 break; 8964 case 29: 8965 { 8966 setState(1049); 8967 theadTagOpen(); 8968 } 8969 break; 8970 case 30: 8971 { 8972 setState(1050); 8973 tfootTagOpen(); 8974 } 8975 break; 8976 case 31: 8977 { 8978 { 8979 setState(1051); 8980 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8981 setState(1052); 8982 match(LEADING_ASTERISK); 8983 } 8984 } 8985 break; 8986 case 32: 8987 { 8988 setState(1053); 8989 htmlComment(); 8990 } 8991 break; 8992 case 33: 8993 { 8994 setState(1054); 8995 match(CDATA); 8996 } 8997 break; 8998 case 34: 8999 { 9000 setState(1055); 9001 match(NEWLINE); 9002 } 9003 break; 9004 case 35: 9005 { 9006 setState(1056); 9007 text(); 9008 } 9009 break; 9010 case 36: 9011 { 9012 setState(1057); 9013 javadocInlineTag(); 9014 } 9015 break; 9016 } 9017 } 9018 } 9019 setState(1062); 9020 _errHandler.sync(this); 9021 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 9022 } 9023 setState(1063); 9024 htmlTagClose(); 9025 } 9026 } 9027 catch (RecognitionException re) { 9028 _localctx.exception = re; 9029 _errHandler.reportError(this, re); 9030 _errHandler.recover(this, re); 9031 } 9032 finally { 9033 exitRule(); 9034 } 9035 return _localctx; 9036 } 9037 9038 public static class OptionTagOpenContext extends ParserRuleContext { 9039 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9040 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 9041 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9042 public List<AttributeContext> attribute() { 9043 return getRuleContexts(AttributeContext.class); 9044 } 9045 public AttributeContext attribute(int i) { 9046 return getRuleContext(AttributeContext.class,i); 9047 } 9048 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9049 public TerminalNode NEWLINE(int i) { 9050 return getToken(JavadocParser.NEWLINE, i); 9051 } 9052 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9053 public TerminalNode LEADING_ASTERISK(int i) { 9054 return getToken(JavadocParser.LEADING_ASTERISK, i); 9055 } 9056 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9057 public TerminalNode WS(int i) { 9058 return getToken(JavadocParser.WS, i); 9059 } 9060 public OptionTagOpenContext(ParserRuleContext parent, int invokingState) { 9061 super(parent, invokingState); 9062 } 9063 @Override public int getRuleIndex() { return RULE_optionTagOpen; } 9064 @Override 9065 public void enterRule(ParseTreeListener listener) { 9066 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagOpen(this); 9067 } 9068 @Override 9069 public void exitRule(ParseTreeListener listener) { 9070 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagOpen(this); 9071 } 9072 @Override 9073 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9074 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagOpen(this); 9075 else return visitor.visitChildren(this); 9076 } 9077 } 9078 9079 public final OptionTagOpenContext optionTagOpen() throws RecognitionException { 9080 OptionTagOpenContext _localctx = new OptionTagOpenContext(_ctx, getState()); 9081 enterRule(_localctx, 78, RULE_optionTagOpen); 9082 int _la; 9083 try { 9084 enterOuterAlt(_localctx, 1); 9085 { 9086 setState(1065); 9087 match(OPEN); 9088 setState(1066); 9089 match(OPTION_HTML_TAG_NAME); 9090 setState(1073); 9091 _errHandler.sync(this); 9092 _la = _input.LA(1); 9093 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9094 { 9095 setState(1071); 9096 _errHandler.sync(this); 9097 switch (_input.LA(1)) { 9098 case HTML_TAG_NAME: 9099 { 9100 setState(1067); 9101 attribute(); 9102 } 9103 break; 9104 case NEWLINE: 9105 { 9106 setState(1068); 9107 match(NEWLINE); 9108 } 9109 break; 9110 case LEADING_ASTERISK: 9111 { 9112 setState(1069); 9113 match(LEADING_ASTERISK); 9114 } 9115 break; 9116 case WS: 9117 { 9118 setState(1070); 9119 match(WS); 9120 } 9121 break; 9122 default: 9123 throw new NoViableAltException(this); 9124 } 9125 } 9126 setState(1075); 9127 _errHandler.sync(this); 9128 _la = _input.LA(1); 9129 } 9130 setState(1076); 9131 match(CLOSE); 9132 } 9133 } 9134 catch (RecognitionException re) { 9135 _localctx.exception = re; 9136 _errHandler.reportError(this, re); 9137 _errHandler.recover(this, re); 9138 } 9139 finally { 9140 exitRule(); 9141 } 9142 return _localctx; 9143 } 9144 9145 public static class OptionTagCloseContext extends ParserRuleContext { 9146 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9147 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9148 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 9149 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9150 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9151 public TerminalNode NEWLINE(int i) { 9152 return getToken(JavadocParser.NEWLINE, i); 9153 } 9154 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9155 public TerminalNode LEADING_ASTERISK(int i) { 9156 return getToken(JavadocParser.LEADING_ASTERISK, i); 9157 } 9158 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9159 public TerminalNode WS(int i) { 9160 return getToken(JavadocParser.WS, i); 9161 } 9162 public OptionTagCloseContext(ParserRuleContext parent, int invokingState) { 9163 super(parent, invokingState); 9164 } 9165 @Override public int getRuleIndex() { return RULE_optionTagClose; } 9166 @Override 9167 public void enterRule(ParseTreeListener listener) { 9168 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagClose(this); 9169 } 9170 @Override 9171 public void exitRule(ParseTreeListener listener) { 9172 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagClose(this); 9173 } 9174 @Override 9175 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9176 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagClose(this); 9177 else return visitor.visitChildren(this); 9178 } 9179 } 9180 9181 public final OptionTagCloseContext optionTagClose() throws RecognitionException { 9182 OptionTagCloseContext _localctx = new OptionTagCloseContext(_ctx, getState()); 9183 enterRule(_localctx, 80, RULE_optionTagClose); 9184 int _la; 9185 try { 9186 enterOuterAlt(_localctx, 1); 9187 { 9188 setState(1078); 9189 match(OPEN); 9190 setState(1079); 9191 match(SLASH); 9192 setState(1080); 9193 match(OPTION_HTML_TAG_NAME); 9194 setState(1084); 9195 _errHandler.sync(this); 9196 _la = _input.LA(1); 9197 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9198 { 9199 { 9200 setState(1081); 9201 _la = _input.LA(1); 9202 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9203 _errHandler.recoverInline(this); 9204 } 9205 else { 9206 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 9207 _errHandler.reportMatch(this); 9208 consume(); 9209 } 9210 } 9211 } 9212 setState(1086); 9213 _errHandler.sync(this); 9214 _la = _input.LA(1); 9215 } 9216 setState(1087); 9217 match(CLOSE); 9218 } 9219 } 9220 catch (RecognitionException re) { 9221 _localctx.exception = re; 9222 _errHandler.reportError(this, re); 9223 _errHandler.recover(this, re); 9224 } 9225 finally { 9226 exitRule(); 9227 } 9228 return _localctx; 9229 } 9230 9231 public static class OptionContext extends ParserRuleContext { 9232 public OptionTagOpenContext optionTagOpen() { 9233 return getRuleContext(OptionTagOpenContext.class,0); 9234 } 9235 public OptionTagCloseContext optionTagClose() { 9236 return getRuleContext(OptionTagCloseContext.class,0); 9237 } 9238 public List<HtmlTagContext> htmlTag() { 9239 return getRuleContexts(HtmlTagContext.class); 9240 } 9241 public HtmlTagContext htmlTag(int i) { 9242 return getRuleContext(HtmlTagContext.class,i); 9243 } 9244 public List<SingletonTagContext> singletonTag() { 9245 return getRuleContexts(SingletonTagContext.class); 9246 } 9247 public SingletonTagContext singletonTag(int i) { 9248 return getRuleContext(SingletonTagContext.class,i); 9249 } 9250 public List<ParagraphContext> paragraph() { 9251 return getRuleContexts(ParagraphContext.class); 9252 } 9253 public ParagraphContext paragraph(int i) { 9254 return getRuleContext(ParagraphContext.class,i); 9255 } 9256 public List<LiContext> li() { 9257 return getRuleContexts(LiContext.class); 9258 } 9259 public LiContext li(int i) { 9260 return getRuleContext(LiContext.class,i); 9261 } 9262 public List<TrContext> tr() { 9263 return getRuleContexts(TrContext.class); 9264 } 9265 public TrContext tr(int i) { 9266 return getRuleContext(TrContext.class,i); 9267 } 9268 public List<TdContext> td() { 9269 return getRuleContexts(TdContext.class); 9270 } 9271 public TdContext td(int i) { 9272 return getRuleContext(TdContext.class,i); 9273 } 9274 public List<ThContext> th() { 9275 return getRuleContexts(ThContext.class); 9276 } 9277 public ThContext th(int i) { 9278 return getRuleContext(ThContext.class,i); 9279 } 9280 public List<BodyContext> body() { 9281 return getRuleContexts(BodyContext.class); 9282 } 9283 public BodyContext body(int i) { 9284 return getRuleContext(BodyContext.class,i); 9285 } 9286 public List<ColgroupContext> colgroup() { 9287 return getRuleContexts(ColgroupContext.class); 9288 } 9289 public ColgroupContext colgroup(int i) { 9290 return getRuleContext(ColgroupContext.class,i); 9291 } 9292 public List<DdContext> dd() { 9293 return getRuleContexts(DdContext.class); 9294 } 9295 public DdContext dd(int i) { 9296 return getRuleContext(DdContext.class,i); 9297 } 9298 public List<DtContext> dt() { 9299 return getRuleContexts(DtContext.class); 9300 } 9301 public DtContext dt(int i) { 9302 return getRuleContext(DtContext.class,i); 9303 } 9304 public List<HeadContext> head() { 9305 return getRuleContexts(HeadContext.class); 9306 } 9307 public HeadContext head(int i) { 9308 return getRuleContext(HeadContext.class,i); 9309 } 9310 public List<HtmlContext> html() { 9311 return getRuleContexts(HtmlContext.class); 9312 } 9313 public HtmlContext html(int i) { 9314 return getRuleContext(HtmlContext.class,i); 9315 } 9316 public List<TbodyContext> tbody() { 9317 return getRuleContexts(TbodyContext.class); 9318 } 9319 public TbodyContext tbody(int i) { 9320 return getRuleContext(TbodyContext.class,i); 9321 } 9322 public List<TheadContext> thead() { 9323 return getRuleContexts(TheadContext.class); 9324 } 9325 public TheadContext thead(int i) { 9326 return getRuleContext(TheadContext.class,i); 9327 } 9328 public List<TfootContext> tfoot() { 9329 return getRuleContexts(TfootContext.class); 9330 } 9331 public TfootContext tfoot(int i) { 9332 return getRuleContext(TfootContext.class,i); 9333 } 9334 public List<PTagOpenContext> pTagOpen() { 9335 return getRuleContexts(PTagOpenContext.class); 9336 } 9337 public PTagOpenContext pTagOpen(int i) { 9338 return getRuleContext(PTagOpenContext.class,i); 9339 } 9340 public List<LiTagOpenContext> liTagOpen() { 9341 return getRuleContexts(LiTagOpenContext.class); 9342 } 9343 public LiTagOpenContext liTagOpen(int i) { 9344 return getRuleContext(LiTagOpenContext.class,i); 9345 } 9346 public List<TrTagOpenContext> trTagOpen() { 9347 return getRuleContexts(TrTagOpenContext.class); 9348 } 9349 public TrTagOpenContext trTagOpen(int i) { 9350 return getRuleContext(TrTagOpenContext.class,i); 9351 } 9352 public List<TdTagOpenContext> tdTagOpen() { 9353 return getRuleContexts(TdTagOpenContext.class); 9354 } 9355 public TdTagOpenContext tdTagOpen(int i) { 9356 return getRuleContext(TdTagOpenContext.class,i); 9357 } 9358 public List<ThTagOpenContext> thTagOpen() { 9359 return getRuleContexts(ThTagOpenContext.class); 9360 } 9361 public ThTagOpenContext thTagOpen(int i) { 9362 return getRuleContext(ThTagOpenContext.class,i); 9363 } 9364 public List<BodyTagOpenContext> bodyTagOpen() { 9365 return getRuleContexts(BodyTagOpenContext.class); 9366 } 9367 public BodyTagOpenContext bodyTagOpen(int i) { 9368 return getRuleContext(BodyTagOpenContext.class,i); 9369 } 9370 public List<ColgroupTagOpenContext> colgroupTagOpen() { 9371 return getRuleContexts(ColgroupTagOpenContext.class); 9372 } 9373 public ColgroupTagOpenContext colgroupTagOpen(int i) { 9374 return getRuleContext(ColgroupTagOpenContext.class,i); 9375 } 9376 public List<DdTagOpenContext> ddTagOpen() { 9377 return getRuleContexts(DdTagOpenContext.class); 9378 } 9379 public DdTagOpenContext ddTagOpen(int i) { 9380 return getRuleContext(DdTagOpenContext.class,i); 9381 } 9382 public List<DtTagOpenContext> dtTagOpen() { 9383 return getRuleContexts(DtTagOpenContext.class); 9384 } 9385 public DtTagOpenContext dtTagOpen(int i) { 9386 return getRuleContext(DtTagOpenContext.class,i); 9387 } 9388 public List<HeadTagOpenContext> headTagOpen() { 9389 return getRuleContexts(HeadTagOpenContext.class); 9390 } 9391 public HeadTagOpenContext headTagOpen(int i) { 9392 return getRuleContext(HeadTagOpenContext.class,i); 9393 } 9394 public List<HtmlTagOpenContext> htmlTagOpen() { 9395 return getRuleContexts(HtmlTagOpenContext.class); 9396 } 9397 public HtmlTagOpenContext htmlTagOpen(int i) { 9398 return getRuleContext(HtmlTagOpenContext.class,i); 9399 } 9400 public List<TbodyTagOpenContext> tbodyTagOpen() { 9401 return getRuleContexts(TbodyTagOpenContext.class); 9402 } 9403 public TbodyTagOpenContext tbodyTagOpen(int i) { 9404 return getRuleContext(TbodyTagOpenContext.class,i); 9405 } 9406 public List<TheadTagOpenContext> theadTagOpen() { 9407 return getRuleContexts(TheadTagOpenContext.class); 9408 } 9409 public TheadTagOpenContext theadTagOpen(int i) { 9410 return getRuleContext(TheadTagOpenContext.class,i); 9411 } 9412 public List<TfootTagOpenContext> tfootTagOpen() { 9413 return getRuleContexts(TfootTagOpenContext.class); 9414 } 9415 public TfootTagOpenContext tfootTagOpen(int i) { 9416 return getRuleContext(TfootTagOpenContext.class,i); 9417 } 9418 public List<HtmlCommentContext> htmlComment() { 9419 return getRuleContexts(HtmlCommentContext.class); 9420 } 9421 public HtmlCommentContext htmlComment(int i) { 9422 return getRuleContext(HtmlCommentContext.class,i); 9423 } 9424 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 9425 public TerminalNode CDATA(int i) { 9426 return getToken(JavadocParser.CDATA, i); 9427 } 9428 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9429 public TerminalNode NEWLINE(int i) { 9430 return getToken(JavadocParser.NEWLINE, i); 9431 } 9432 public List<TextContext> text() { 9433 return getRuleContexts(TextContext.class); 9434 } 9435 public TextContext text(int i) { 9436 return getRuleContext(TextContext.class,i); 9437 } 9438 public List<JavadocInlineTagContext> javadocInlineTag() { 9439 return getRuleContexts(JavadocInlineTagContext.class); 9440 } 9441 public JavadocInlineTagContext javadocInlineTag(int i) { 9442 return getRuleContext(JavadocInlineTagContext.class,i); 9443 } 9444 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9445 public TerminalNode LEADING_ASTERISK(int i) { 9446 return getToken(JavadocParser.LEADING_ASTERISK, i); 9447 } 9448 public OptionContext(ParserRuleContext parent, int invokingState) { 9449 super(parent, invokingState); 9450 } 9451 @Override public int getRuleIndex() { return RULE_option; } 9452 @Override 9453 public void enterRule(ParseTreeListener listener) { 9454 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOption(this); 9455 } 9456 @Override 9457 public void exitRule(ParseTreeListener listener) { 9458 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOption(this); 9459 } 9460 @Override 9461 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9462 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOption(this); 9463 else return visitor.visitChildren(this); 9464 } 9465 } 9466 9467 public final OptionContext option() throws RecognitionException { 9468 OptionContext _localctx = new OptionContext(_ctx, getState()); 9469 enterRule(_localctx, 82, RULE_option); 9470 try { 9471 int _alt; 9472 enterOuterAlt(_localctx, 1); 9473 { 9474 setState(1089); 9475 optionTagOpen(); 9476 setState(1129); 9477 _errHandler.sync(this); 9478 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 9479 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 9480 if ( _alt==1 ) { 9481 { 9482 setState(1127); 9483 _errHandler.sync(this); 9484 switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { 9485 case 1: 9486 { 9487 setState(1090); 9488 htmlTag(); 9489 } 9490 break; 9491 case 2: 9492 { 9493 setState(1091); 9494 singletonTag(); 9495 } 9496 break; 9497 case 3: 9498 { 9499 setState(1092); 9500 paragraph(); 9501 } 9502 break; 9503 case 4: 9504 { 9505 setState(1093); 9506 li(); 9507 } 9508 break; 9509 case 5: 9510 { 9511 setState(1094); 9512 tr(); 9513 } 9514 break; 9515 case 6: 9516 { 9517 setState(1095); 9518 td(); 9519 } 9520 break; 9521 case 7: 9522 { 9523 setState(1096); 9524 th(); 9525 } 9526 break; 9527 case 8: 9528 { 9529 setState(1097); 9530 body(); 9531 } 9532 break; 9533 case 9: 9534 { 9535 setState(1098); 9536 colgroup(); 9537 } 9538 break; 9539 case 10: 9540 { 9541 setState(1099); 9542 dd(); 9543 } 9544 break; 9545 case 11: 9546 { 9547 setState(1100); 9548 dt(); 9549 } 9550 break; 9551 case 12: 9552 { 9553 setState(1101); 9554 head(); 9555 } 9556 break; 9557 case 13: 9558 { 9559 setState(1102); 9560 html(); 9561 } 9562 break; 9563 case 14: 9564 { 9565 setState(1103); 9566 tbody(); 9567 } 9568 break; 9569 case 15: 9570 { 9571 setState(1104); 9572 thead(); 9573 } 9574 break; 9575 case 16: 9576 { 9577 setState(1105); 9578 tfoot(); 9579 } 9580 break; 9581 case 17: 9582 { 9583 setState(1106); 9584 pTagOpen(); 9585 } 9586 break; 9587 case 18: 9588 { 9589 setState(1107); 9590 liTagOpen(); 9591 } 9592 break; 9593 case 19: 9594 { 9595 setState(1108); 9596 trTagOpen(); 9597 } 9598 break; 9599 case 20: 9600 { 9601 setState(1109); 9602 tdTagOpen(); 9603 } 9604 break; 9605 case 21: 9606 { 9607 setState(1110); 9608 thTagOpen(); 9609 } 9610 break; 9611 case 22: 9612 { 9613 setState(1111); 9614 bodyTagOpen(); 9615 } 9616 break; 9617 case 23: 9618 { 9619 setState(1112); 9620 colgroupTagOpen(); 9621 } 9622 break; 9623 case 24: 9624 { 9625 setState(1113); 9626 ddTagOpen(); 9627 } 9628 break; 9629 case 25: 9630 { 9631 setState(1114); 9632 dtTagOpen(); 9633 } 9634 break; 9635 case 26: 9636 { 9637 setState(1115); 9638 headTagOpen(); 9639 } 9640 break; 9641 case 27: 9642 { 9643 setState(1116); 9644 htmlTagOpen(); 9645 } 9646 break; 9647 case 28: 9648 { 9649 setState(1117); 9650 tbodyTagOpen(); 9651 } 9652 break; 9653 case 29: 9654 { 9655 setState(1118); 9656 theadTagOpen(); 9657 } 9658 break; 9659 case 30: 9660 { 9661 setState(1119); 9662 tfootTagOpen(); 9663 } 9664 break; 9665 case 31: 9666 { 9667 { 9668 setState(1120); 9669 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 9670 setState(1121); 9671 match(LEADING_ASTERISK); 9672 } 9673 } 9674 break; 9675 case 32: 9676 { 9677 setState(1122); 9678 htmlComment(); 9679 } 9680 break; 9681 case 33: 9682 { 9683 setState(1123); 9684 match(CDATA); 9685 } 9686 break; 9687 case 34: 9688 { 9689 setState(1124); 9690 match(NEWLINE); 9691 } 9692 break; 9693 case 35: 9694 { 9695 setState(1125); 9696 text(); 9697 } 9698 break; 9699 case 36: 9700 { 9701 setState(1126); 9702 javadocInlineTag(); 9703 } 9704 break; 9705 } 9706 } 9707 } 9708 setState(1131); 9709 _errHandler.sync(this); 9710 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 9711 } 9712 setState(1132); 9713 optionTagClose(); 9714 } 9715 } 9716 catch (RecognitionException re) { 9717 _localctx.exception = re; 9718 _errHandler.reportError(this, re); 9719 _errHandler.recover(this, re); 9720 } 9721 finally { 9722 exitRule(); 9723 } 9724 return _localctx; 9725 } 9726 9727 public static class TbodyTagOpenContext extends ParserRuleContext { 9728 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9729 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9730 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9731 public List<AttributeContext> attribute() { 9732 return getRuleContexts(AttributeContext.class); 9733 } 9734 public AttributeContext attribute(int i) { 9735 return getRuleContext(AttributeContext.class,i); 9736 } 9737 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9738 public TerminalNode NEWLINE(int i) { 9739 return getToken(JavadocParser.NEWLINE, i); 9740 } 9741 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9742 public TerminalNode LEADING_ASTERISK(int i) { 9743 return getToken(JavadocParser.LEADING_ASTERISK, i); 9744 } 9745 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9746 public TerminalNode WS(int i) { 9747 return getToken(JavadocParser.WS, i); 9748 } 9749 public TbodyTagOpenContext(ParserRuleContext parent, int invokingState) { 9750 super(parent, invokingState); 9751 } 9752 @Override public int getRuleIndex() { return RULE_tbodyTagOpen; } 9753 @Override 9754 public void enterRule(ParseTreeListener listener) { 9755 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagOpen(this); 9756 } 9757 @Override 9758 public void exitRule(ParseTreeListener listener) { 9759 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagOpen(this); 9760 } 9761 @Override 9762 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9763 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagOpen(this); 9764 else return visitor.visitChildren(this); 9765 } 9766 } 9767 9768 public final TbodyTagOpenContext tbodyTagOpen() throws RecognitionException { 9769 TbodyTagOpenContext _localctx = new TbodyTagOpenContext(_ctx, getState()); 9770 enterRule(_localctx, 84, RULE_tbodyTagOpen); 9771 int _la; 9772 try { 9773 enterOuterAlt(_localctx, 1); 9774 { 9775 setState(1134); 9776 match(OPEN); 9777 setState(1135); 9778 match(TBODY_HTML_TAG_NAME); 9779 setState(1142); 9780 _errHandler.sync(this); 9781 _la = _input.LA(1); 9782 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9783 { 9784 setState(1140); 9785 _errHandler.sync(this); 9786 switch (_input.LA(1)) { 9787 case HTML_TAG_NAME: 9788 { 9789 setState(1136); 9790 attribute(); 9791 } 9792 break; 9793 case NEWLINE: 9794 { 9795 setState(1137); 9796 match(NEWLINE); 9797 } 9798 break; 9799 case LEADING_ASTERISK: 9800 { 9801 setState(1138); 9802 match(LEADING_ASTERISK); 9803 } 9804 break; 9805 case WS: 9806 { 9807 setState(1139); 9808 match(WS); 9809 } 9810 break; 9811 default: 9812 throw new NoViableAltException(this); 9813 } 9814 } 9815 setState(1144); 9816 _errHandler.sync(this); 9817 _la = _input.LA(1); 9818 } 9819 setState(1145); 9820 match(CLOSE); 9821 } 9822 } 9823 catch (RecognitionException re) { 9824 _localctx.exception = re; 9825 _errHandler.reportError(this, re); 9826 _errHandler.recover(this, re); 9827 } 9828 finally { 9829 exitRule(); 9830 } 9831 return _localctx; 9832 } 9833 9834 public static class TbodyTagCloseContext extends ParserRuleContext { 9835 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9836 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9837 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9838 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9839 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9840 public TerminalNode NEWLINE(int i) { 9841 return getToken(JavadocParser.NEWLINE, i); 9842 } 9843 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9844 public TerminalNode LEADING_ASTERISK(int i) { 9845 return getToken(JavadocParser.LEADING_ASTERISK, i); 9846 } 9847 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9848 public TerminalNode WS(int i) { 9849 return getToken(JavadocParser.WS, i); 9850 } 9851 public TbodyTagCloseContext(ParserRuleContext parent, int invokingState) { 9852 super(parent, invokingState); 9853 } 9854 @Override public int getRuleIndex() { return RULE_tbodyTagClose; } 9855 @Override 9856 public void enterRule(ParseTreeListener listener) { 9857 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagClose(this); 9858 } 9859 @Override 9860 public void exitRule(ParseTreeListener listener) { 9861 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagClose(this); 9862 } 9863 @Override 9864 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9865 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagClose(this); 9866 else return visitor.visitChildren(this); 9867 } 9868 } 9869 9870 public final TbodyTagCloseContext tbodyTagClose() throws RecognitionException { 9871 TbodyTagCloseContext _localctx = new TbodyTagCloseContext(_ctx, getState()); 9872 enterRule(_localctx, 86, RULE_tbodyTagClose); 9873 int _la; 9874 try { 9875 enterOuterAlt(_localctx, 1); 9876 { 9877 setState(1147); 9878 match(OPEN); 9879 setState(1148); 9880 match(SLASH); 9881 setState(1149); 9882 match(TBODY_HTML_TAG_NAME); 9883 setState(1153); 9884 _errHandler.sync(this); 9885 _la = _input.LA(1); 9886 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9887 { 9888 { 9889 setState(1150); 9890 _la = _input.LA(1); 9891 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9892 _errHandler.recoverInline(this); 9893 } 9894 else { 9895 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 9896 _errHandler.reportMatch(this); 9897 consume(); 9898 } 9899 } 9900 } 9901 setState(1155); 9902 _errHandler.sync(this); 9903 _la = _input.LA(1); 9904 } 9905 setState(1156); 9906 match(CLOSE); 9907 } 9908 } 9909 catch (RecognitionException re) { 9910 _localctx.exception = re; 9911 _errHandler.reportError(this, re); 9912 _errHandler.recover(this, re); 9913 } 9914 finally { 9915 exitRule(); 9916 } 9917 return _localctx; 9918 } 9919 9920 public static class TbodyContext extends ParserRuleContext { 9921 public TbodyTagOpenContext tbodyTagOpen() { 9922 return getRuleContext(TbodyTagOpenContext.class,0); 9923 } 9924 public TbodyTagCloseContext tbodyTagClose() { 9925 return getRuleContext(TbodyTagCloseContext.class,0); 9926 } 9927 public List<HtmlTagContext> htmlTag() { 9928 return getRuleContexts(HtmlTagContext.class); 9929 } 9930 public HtmlTagContext htmlTag(int i) { 9931 return getRuleContext(HtmlTagContext.class,i); 9932 } 9933 public List<SingletonTagContext> singletonTag() { 9934 return getRuleContexts(SingletonTagContext.class); 9935 } 9936 public SingletonTagContext singletonTag(int i) { 9937 return getRuleContext(SingletonTagContext.class,i); 9938 } 9939 public List<ParagraphContext> paragraph() { 9940 return getRuleContexts(ParagraphContext.class); 9941 } 9942 public ParagraphContext paragraph(int i) { 9943 return getRuleContext(ParagraphContext.class,i); 9944 } 9945 public List<LiContext> li() { 9946 return getRuleContexts(LiContext.class); 9947 } 9948 public LiContext li(int i) { 9949 return getRuleContext(LiContext.class,i); 9950 } 9951 public List<TrContext> tr() { 9952 return getRuleContexts(TrContext.class); 9953 } 9954 public TrContext tr(int i) { 9955 return getRuleContext(TrContext.class,i); 9956 } 9957 public List<TdContext> td() { 9958 return getRuleContexts(TdContext.class); 9959 } 9960 public TdContext td(int i) { 9961 return getRuleContext(TdContext.class,i); 9962 } 9963 public List<ThContext> th() { 9964 return getRuleContexts(ThContext.class); 9965 } 9966 public ThContext th(int i) { 9967 return getRuleContext(ThContext.class,i); 9968 } 9969 public List<BodyContext> body() { 9970 return getRuleContexts(BodyContext.class); 9971 } 9972 public BodyContext body(int i) { 9973 return getRuleContext(BodyContext.class,i); 9974 } 9975 public List<ColgroupContext> colgroup() { 9976 return getRuleContexts(ColgroupContext.class); 9977 } 9978 public ColgroupContext colgroup(int i) { 9979 return getRuleContext(ColgroupContext.class,i); 9980 } 9981 public List<DdContext> dd() { 9982 return getRuleContexts(DdContext.class); 9983 } 9984 public DdContext dd(int i) { 9985 return getRuleContext(DdContext.class,i); 9986 } 9987 public List<DtContext> dt() { 9988 return getRuleContexts(DtContext.class); 9989 } 9990 public DtContext dt(int i) { 9991 return getRuleContext(DtContext.class,i); 9992 } 9993 public List<HeadContext> head() { 9994 return getRuleContexts(HeadContext.class); 9995 } 9996 public HeadContext head(int i) { 9997 return getRuleContext(HeadContext.class,i); 9998 } 9999 public List<HtmlContext> html() { 10000 return getRuleContexts(HtmlContext.class); 10001 } 10002 public HtmlContext html(int i) { 10003 return getRuleContext(HtmlContext.class,i); 10004 } 10005 public List<OptionContext> option() { 10006 return getRuleContexts(OptionContext.class); 10007 } 10008 public OptionContext option(int i) { 10009 return getRuleContext(OptionContext.class,i); 10010 } 10011 public List<TheadContext> thead() { 10012 return getRuleContexts(TheadContext.class); 10013 } 10014 public TheadContext thead(int i) { 10015 return getRuleContext(TheadContext.class,i); 10016 } 10017 public List<TfootContext> tfoot() { 10018 return getRuleContexts(TfootContext.class); 10019 } 10020 public TfootContext tfoot(int i) { 10021 return getRuleContext(TfootContext.class,i); 10022 } 10023 public List<PTagOpenContext> pTagOpen() { 10024 return getRuleContexts(PTagOpenContext.class); 10025 } 10026 public PTagOpenContext pTagOpen(int i) { 10027 return getRuleContext(PTagOpenContext.class,i); 10028 } 10029 public List<LiTagOpenContext> liTagOpen() { 10030 return getRuleContexts(LiTagOpenContext.class); 10031 } 10032 public LiTagOpenContext liTagOpen(int i) { 10033 return getRuleContext(LiTagOpenContext.class,i); 10034 } 10035 public List<TrTagOpenContext> trTagOpen() { 10036 return getRuleContexts(TrTagOpenContext.class); 10037 } 10038 public TrTagOpenContext trTagOpen(int i) { 10039 return getRuleContext(TrTagOpenContext.class,i); 10040 } 10041 public List<TdTagOpenContext> tdTagOpen() { 10042 return getRuleContexts(TdTagOpenContext.class); 10043 } 10044 public TdTagOpenContext tdTagOpen(int i) { 10045 return getRuleContext(TdTagOpenContext.class,i); 10046 } 10047 public List<ThTagOpenContext> thTagOpen() { 10048 return getRuleContexts(ThTagOpenContext.class); 10049 } 10050 public ThTagOpenContext thTagOpen(int i) { 10051 return getRuleContext(ThTagOpenContext.class,i); 10052 } 10053 public List<BodyTagOpenContext> bodyTagOpen() { 10054 return getRuleContexts(BodyTagOpenContext.class); 10055 } 10056 public BodyTagOpenContext bodyTagOpen(int i) { 10057 return getRuleContext(BodyTagOpenContext.class,i); 10058 } 10059 public List<ColgroupTagOpenContext> colgroupTagOpen() { 10060 return getRuleContexts(ColgroupTagOpenContext.class); 10061 } 10062 public ColgroupTagOpenContext colgroupTagOpen(int i) { 10063 return getRuleContext(ColgroupTagOpenContext.class,i); 10064 } 10065 public List<DdTagOpenContext> ddTagOpen() { 10066 return getRuleContexts(DdTagOpenContext.class); 10067 } 10068 public DdTagOpenContext ddTagOpen(int i) { 10069 return getRuleContext(DdTagOpenContext.class,i); 10070 } 10071 public List<DtTagOpenContext> dtTagOpen() { 10072 return getRuleContexts(DtTagOpenContext.class); 10073 } 10074 public DtTagOpenContext dtTagOpen(int i) { 10075 return getRuleContext(DtTagOpenContext.class,i); 10076 } 10077 public List<HeadTagOpenContext> headTagOpen() { 10078 return getRuleContexts(HeadTagOpenContext.class); 10079 } 10080 public HeadTagOpenContext headTagOpen(int i) { 10081 return getRuleContext(HeadTagOpenContext.class,i); 10082 } 10083 public List<HtmlTagOpenContext> htmlTagOpen() { 10084 return getRuleContexts(HtmlTagOpenContext.class); 10085 } 10086 public HtmlTagOpenContext htmlTagOpen(int i) { 10087 return getRuleContext(HtmlTagOpenContext.class,i); 10088 } 10089 public List<OptionTagOpenContext> optionTagOpen() { 10090 return getRuleContexts(OptionTagOpenContext.class); 10091 } 10092 public OptionTagOpenContext optionTagOpen(int i) { 10093 return getRuleContext(OptionTagOpenContext.class,i); 10094 } 10095 public List<TheadTagOpenContext> theadTagOpen() { 10096 return getRuleContexts(TheadTagOpenContext.class); 10097 } 10098 public TheadTagOpenContext theadTagOpen(int i) { 10099 return getRuleContext(TheadTagOpenContext.class,i); 10100 } 10101 public List<TfootTagOpenContext> tfootTagOpen() { 10102 return getRuleContexts(TfootTagOpenContext.class); 10103 } 10104 public TfootTagOpenContext tfootTagOpen(int i) { 10105 return getRuleContext(TfootTagOpenContext.class,i); 10106 } 10107 public List<HtmlCommentContext> htmlComment() { 10108 return getRuleContexts(HtmlCommentContext.class); 10109 } 10110 public HtmlCommentContext htmlComment(int i) { 10111 return getRuleContext(HtmlCommentContext.class,i); 10112 } 10113 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10114 public TerminalNode CDATA(int i) { 10115 return getToken(JavadocParser.CDATA, i); 10116 } 10117 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10118 public TerminalNode NEWLINE(int i) { 10119 return getToken(JavadocParser.NEWLINE, i); 10120 } 10121 public List<TextContext> text() { 10122 return getRuleContexts(TextContext.class); 10123 } 10124 public TextContext text(int i) { 10125 return getRuleContext(TextContext.class,i); 10126 } 10127 public List<JavadocInlineTagContext> javadocInlineTag() { 10128 return getRuleContexts(JavadocInlineTagContext.class); 10129 } 10130 public JavadocInlineTagContext javadocInlineTag(int i) { 10131 return getRuleContext(JavadocInlineTagContext.class,i); 10132 } 10133 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10134 public TerminalNode LEADING_ASTERISK(int i) { 10135 return getToken(JavadocParser.LEADING_ASTERISK, i); 10136 } 10137 public TbodyContext(ParserRuleContext parent, int invokingState) { 10138 super(parent, invokingState); 10139 } 10140 @Override public int getRuleIndex() { return RULE_tbody; } 10141 @Override 10142 public void enterRule(ParseTreeListener listener) { 10143 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbody(this); 10144 } 10145 @Override 10146 public void exitRule(ParseTreeListener listener) { 10147 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbody(this); 10148 } 10149 @Override 10150 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10151 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbody(this); 10152 else return visitor.visitChildren(this); 10153 } 10154 } 10155 10156 public final TbodyContext tbody() throws RecognitionException { 10157 TbodyContext _localctx = new TbodyContext(_ctx, getState()); 10158 enterRule(_localctx, 88, RULE_tbody); 10159 try { 10160 int _alt; 10161 enterOuterAlt(_localctx, 1); 10162 { 10163 setState(1158); 10164 tbodyTagOpen(); 10165 setState(1198); 10166 _errHandler.sync(this); 10167 _alt = getInterpreter().adaptivePredict(_input,81,_ctx); 10168 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10169 if ( _alt==1 ) { 10170 { 10171 setState(1196); 10172 _errHandler.sync(this); 10173 switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) { 10174 case 1: 10175 { 10176 setState(1159); 10177 htmlTag(); 10178 } 10179 break; 10180 case 2: 10181 { 10182 setState(1160); 10183 singletonTag(); 10184 } 10185 break; 10186 case 3: 10187 { 10188 setState(1161); 10189 paragraph(); 10190 } 10191 break; 10192 case 4: 10193 { 10194 setState(1162); 10195 li(); 10196 } 10197 break; 10198 case 5: 10199 { 10200 setState(1163); 10201 tr(); 10202 } 10203 break; 10204 case 6: 10205 { 10206 setState(1164); 10207 td(); 10208 } 10209 break; 10210 case 7: 10211 { 10212 setState(1165); 10213 th(); 10214 } 10215 break; 10216 case 8: 10217 { 10218 setState(1166); 10219 body(); 10220 } 10221 break; 10222 case 9: 10223 { 10224 setState(1167); 10225 colgroup(); 10226 } 10227 break; 10228 case 10: 10229 { 10230 setState(1168); 10231 dd(); 10232 } 10233 break; 10234 case 11: 10235 { 10236 setState(1169); 10237 dt(); 10238 } 10239 break; 10240 case 12: 10241 { 10242 setState(1170); 10243 head(); 10244 } 10245 break; 10246 case 13: 10247 { 10248 setState(1171); 10249 html(); 10250 } 10251 break; 10252 case 14: 10253 { 10254 setState(1172); 10255 option(); 10256 } 10257 break; 10258 case 15: 10259 { 10260 setState(1173); 10261 thead(); 10262 } 10263 break; 10264 case 16: 10265 { 10266 setState(1174); 10267 tfoot(); 10268 } 10269 break; 10270 case 17: 10271 { 10272 setState(1175); 10273 pTagOpen(); 10274 } 10275 break; 10276 case 18: 10277 { 10278 setState(1176); 10279 liTagOpen(); 10280 } 10281 break; 10282 case 19: 10283 { 10284 setState(1177); 10285 trTagOpen(); 10286 } 10287 break; 10288 case 20: 10289 { 10290 setState(1178); 10291 tdTagOpen(); 10292 } 10293 break; 10294 case 21: 10295 { 10296 setState(1179); 10297 thTagOpen(); 10298 } 10299 break; 10300 case 22: 10301 { 10302 setState(1180); 10303 bodyTagOpen(); 10304 } 10305 break; 10306 case 23: 10307 { 10308 setState(1181); 10309 colgroupTagOpen(); 10310 } 10311 break; 10312 case 24: 10313 { 10314 setState(1182); 10315 ddTagOpen(); 10316 } 10317 break; 10318 case 25: 10319 { 10320 setState(1183); 10321 dtTagOpen(); 10322 } 10323 break; 10324 case 26: 10325 { 10326 setState(1184); 10327 headTagOpen(); 10328 } 10329 break; 10330 case 27: 10331 { 10332 setState(1185); 10333 htmlTagOpen(); 10334 } 10335 break; 10336 case 28: 10337 { 10338 setState(1186); 10339 optionTagOpen(); 10340 } 10341 break; 10342 case 29: 10343 { 10344 setState(1187); 10345 theadTagOpen(); 10346 } 10347 break; 10348 case 30: 10349 { 10350 setState(1188); 10351 tfootTagOpen(); 10352 } 10353 break; 10354 case 31: 10355 { 10356 { 10357 setState(1189); 10358 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10359 setState(1190); 10360 match(LEADING_ASTERISK); 10361 } 10362 } 10363 break; 10364 case 32: 10365 { 10366 setState(1191); 10367 htmlComment(); 10368 } 10369 break; 10370 case 33: 10371 { 10372 setState(1192); 10373 match(CDATA); 10374 } 10375 break; 10376 case 34: 10377 { 10378 setState(1193); 10379 match(NEWLINE); 10380 } 10381 break; 10382 case 35: 10383 { 10384 setState(1194); 10385 text(); 10386 } 10387 break; 10388 case 36: 10389 { 10390 setState(1195); 10391 javadocInlineTag(); 10392 } 10393 break; 10394 } 10395 } 10396 } 10397 setState(1200); 10398 _errHandler.sync(this); 10399 _alt = getInterpreter().adaptivePredict(_input,81,_ctx); 10400 } 10401 setState(1201); 10402 tbodyTagClose(); 10403 } 10404 } 10405 catch (RecognitionException re) { 10406 _localctx.exception = re; 10407 _errHandler.reportError(this, re); 10408 _errHandler.recover(this, re); 10409 } 10410 finally { 10411 exitRule(); 10412 } 10413 return _localctx; 10414 } 10415 10416 public static class TfootTagOpenContext extends ParserRuleContext { 10417 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10418 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 10419 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10420 public List<AttributeContext> attribute() { 10421 return getRuleContexts(AttributeContext.class); 10422 } 10423 public AttributeContext attribute(int i) { 10424 return getRuleContext(AttributeContext.class,i); 10425 } 10426 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10427 public TerminalNode NEWLINE(int i) { 10428 return getToken(JavadocParser.NEWLINE, i); 10429 } 10430 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10431 public TerminalNode LEADING_ASTERISK(int i) { 10432 return getToken(JavadocParser.LEADING_ASTERISK, i); 10433 } 10434 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10435 public TerminalNode WS(int i) { 10436 return getToken(JavadocParser.WS, i); 10437 } 10438 public TfootTagOpenContext(ParserRuleContext parent, int invokingState) { 10439 super(parent, invokingState); 10440 } 10441 @Override public int getRuleIndex() { return RULE_tfootTagOpen; } 10442 @Override 10443 public void enterRule(ParseTreeListener listener) { 10444 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagOpen(this); 10445 } 10446 @Override 10447 public void exitRule(ParseTreeListener listener) { 10448 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagOpen(this); 10449 } 10450 @Override 10451 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10452 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagOpen(this); 10453 else return visitor.visitChildren(this); 10454 } 10455 } 10456 10457 public final TfootTagOpenContext tfootTagOpen() throws RecognitionException { 10458 TfootTagOpenContext _localctx = new TfootTagOpenContext(_ctx, getState()); 10459 enterRule(_localctx, 90, RULE_tfootTagOpen); 10460 int _la; 10461 try { 10462 enterOuterAlt(_localctx, 1); 10463 { 10464 setState(1203); 10465 match(OPEN); 10466 setState(1204); 10467 match(TFOOT_HTML_TAG_NAME); 10468 setState(1211); 10469 _errHandler.sync(this); 10470 _la = _input.LA(1); 10471 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 10472 { 10473 setState(1209); 10474 _errHandler.sync(this); 10475 switch (_input.LA(1)) { 10476 case HTML_TAG_NAME: 10477 { 10478 setState(1205); 10479 attribute(); 10480 } 10481 break; 10482 case NEWLINE: 10483 { 10484 setState(1206); 10485 match(NEWLINE); 10486 } 10487 break; 10488 case LEADING_ASTERISK: 10489 { 10490 setState(1207); 10491 match(LEADING_ASTERISK); 10492 } 10493 break; 10494 case WS: 10495 { 10496 setState(1208); 10497 match(WS); 10498 } 10499 break; 10500 default: 10501 throw new NoViableAltException(this); 10502 } 10503 } 10504 setState(1213); 10505 _errHandler.sync(this); 10506 _la = _input.LA(1); 10507 } 10508 setState(1214); 10509 match(CLOSE); 10510 } 10511 } 10512 catch (RecognitionException re) { 10513 _localctx.exception = re; 10514 _errHandler.reportError(this, re); 10515 _errHandler.recover(this, re); 10516 } 10517 finally { 10518 exitRule(); 10519 } 10520 return _localctx; 10521 } 10522 10523 public static class TfootTagCloseContext extends ParserRuleContext { 10524 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10525 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 10526 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 10527 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10528 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10529 public TerminalNode NEWLINE(int i) { 10530 return getToken(JavadocParser.NEWLINE, i); 10531 } 10532 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10533 public TerminalNode LEADING_ASTERISK(int i) { 10534 return getToken(JavadocParser.LEADING_ASTERISK, i); 10535 } 10536 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10537 public TerminalNode WS(int i) { 10538 return getToken(JavadocParser.WS, i); 10539 } 10540 public TfootTagCloseContext(ParserRuleContext parent, int invokingState) { 10541 super(parent, invokingState); 10542 } 10543 @Override public int getRuleIndex() { return RULE_tfootTagClose; } 10544 @Override 10545 public void enterRule(ParseTreeListener listener) { 10546 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagClose(this); 10547 } 10548 @Override 10549 public void exitRule(ParseTreeListener listener) { 10550 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagClose(this); 10551 } 10552 @Override 10553 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10554 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagClose(this); 10555 else return visitor.visitChildren(this); 10556 } 10557 } 10558 10559 public final TfootTagCloseContext tfootTagClose() throws RecognitionException { 10560 TfootTagCloseContext _localctx = new TfootTagCloseContext(_ctx, getState()); 10561 enterRule(_localctx, 92, RULE_tfootTagClose); 10562 int _la; 10563 try { 10564 enterOuterAlt(_localctx, 1); 10565 { 10566 setState(1216); 10567 match(OPEN); 10568 setState(1217); 10569 match(SLASH); 10570 setState(1218); 10571 match(TFOOT_HTML_TAG_NAME); 10572 setState(1222); 10573 _errHandler.sync(this); 10574 _la = _input.LA(1); 10575 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10576 { 10577 { 10578 setState(1219); 10579 _la = _input.LA(1); 10580 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10581 _errHandler.recoverInline(this); 10582 } 10583 else { 10584 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 10585 _errHandler.reportMatch(this); 10586 consume(); 10587 } 10588 } 10589 } 10590 setState(1224); 10591 _errHandler.sync(this); 10592 _la = _input.LA(1); 10593 } 10594 setState(1225); 10595 match(CLOSE); 10596 } 10597 } 10598 catch (RecognitionException re) { 10599 _localctx.exception = re; 10600 _errHandler.reportError(this, re); 10601 _errHandler.recover(this, re); 10602 } 10603 finally { 10604 exitRule(); 10605 } 10606 return _localctx; 10607 } 10608 10609 public static class TfootContext extends ParserRuleContext { 10610 public TfootTagOpenContext tfootTagOpen() { 10611 return getRuleContext(TfootTagOpenContext.class,0); 10612 } 10613 public TfootTagCloseContext tfootTagClose() { 10614 return getRuleContext(TfootTagCloseContext.class,0); 10615 } 10616 public List<HtmlTagContext> htmlTag() { 10617 return getRuleContexts(HtmlTagContext.class); 10618 } 10619 public HtmlTagContext htmlTag(int i) { 10620 return getRuleContext(HtmlTagContext.class,i); 10621 } 10622 public List<SingletonTagContext> singletonTag() { 10623 return getRuleContexts(SingletonTagContext.class); 10624 } 10625 public SingletonTagContext singletonTag(int i) { 10626 return getRuleContext(SingletonTagContext.class,i); 10627 } 10628 public List<ParagraphContext> paragraph() { 10629 return getRuleContexts(ParagraphContext.class); 10630 } 10631 public ParagraphContext paragraph(int i) { 10632 return getRuleContext(ParagraphContext.class,i); 10633 } 10634 public List<LiContext> li() { 10635 return getRuleContexts(LiContext.class); 10636 } 10637 public LiContext li(int i) { 10638 return getRuleContext(LiContext.class,i); 10639 } 10640 public List<TrContext> tr() { 10641 return getRuleContexts(TrContext.class); 10642 } 10643 public TrContext tr(int i) { 10644 return getRuleContext(TrContext.class,i); 10645 } 10646 public List<TdContext> td() { 10647 return getRuleContexts(TdContext.class); 10648 } 10649 public TdContext td(int i) { 10650 return getRuleContext(TdContext.class,i); 10651 } 10652 public List<ThContext> th() { 10653 return getRuleContexts(ThContext.class); 10654 } 10655 public ThContext th(int i) { 10656 return getRuleContext(ThContext.class,i); 10657 } 10658 public List<BodyContext> body() { 10659 return getRuleContexts(BodyContext.class); 10660 } 10661 public BodyContext body(int i) { 10662 return getRuleContext(BodyContext.class,i); 10663 } 10664 public List<ColgroupContext> colgroup() { 10665 return getRuleContexts(ColgroupContext.class); 10666 } 10667 public ColgroupContext colgroup(int i) { 10668 return getRuleContext(ColgroupContext.class,i); 10669 } 10670 public List<DdContext> dd() { 10671 return getRuleContexts(DdContext.class); 10672 } 10673 public DdContext dd(int i) { 10674 return getRuleContext(DdContext.class,i); 10675 } 10676 public List<DtContext> dt() { 10677 return getRuleContexts(DtContext.class); 10678 } 10679 public DtContext dt(int i) { 10680 return getRuleContext(DtContext.class,i); 10681 } 10682 public List<HeadContext> head() { 10683 return getRuleContexts(HeadContext.class); 10684 } 10685 public HeadContext head(int i) { 10686 return getRuleContext(HeadContext.class,i); 10687 } 10688 public List<HtmlContext> html() { 10689 return getRuleContexts(HtmlContext.class); 10690 } 10691 public HtmlContext html(int i) { 10692 return getRuleContext(HtmlContext.class,i); 10693 } 10694 public List<OptionContext> option() { 10695 return getRuleContexts(OptionContext.class); 10696 } 10697 public OptionContext option(int i) { 10698 return getRuleContext(OptionContext.class,i); 10699 } 10700 public List<TbodyContext> tbody() { 10701 return getRuleContexts(TbodyContext.class); 10702 } 10703 public TbodyContext tbody(int i) { 10704 return getRuleContext(TbodyContext.class,i); 10705 } 10706 public List<TheadContext> thead() { 10707 return getRuleContexts(TheadContext.class); 10708 } 10709 public TheadContext thead(int i) { 10710 return getRuleContext(TheadContext.class,i); 10711 } 10712 public List<PTagOpenContext> pTagOpen() { 10713 return getRuleContexts(PTagOpenContext.class); 10714 } 10715 public PTagOpenContext pTagOpen(int i) { 10716 return getRuleContext(PTagOpenContext.class,i); 10717 } 10718 public List<LiTagOpenContext> liTagOpen() { 10719 return getRuleContexts(LiTagOpenContext.class); 10720 } 10721 public LiTagOpenContext liTagOpen(int i) { 10722 return getRuleContext(LiTagOpenContext.class,i); 10723 } 10724 public List<TrTagOpenContext> trTagOpen() { 10725 return getRuleContexts(TrTagOpenContext.class); 10726 } 10727 public TrTagOpenContext trTagOpen(int i) { 10728 return getRuleContext(TrTagOpenContext.class,i); 10729 } 10730 public List<TdTagOpenContext> tdTagOpen() { 10731 return getRuleContexts(TdTagOpenContext.class); 10732 } 10733 public TdTagOpenContext tdTagOpen(int i) { 10734 return getRuleContext(TdTagOpenContext.class,i); 10735 } 10736 public List<ThTagOpenContext> thTagOpen() { 10737 return getRuleContexts(ThTagOpenContext.class); 10738 } 10739 public ThTagOpenContext thTagOpen(int i) { 10740 return getRuleContext(ThTagOpenContext.class,i); 10741 } 10742 public List<BodyTagOpenContext> bodyTagOpen() { 10743 return getRuleContexts(BodyTagOpenContext.class); 10744 } 10745 public BodyTagOpenContext bodyTagOpen(int i) { 10746 return getRuleContext(BodyTagOpenContext.class,i); 10747 } 10748 public List<ColgroupTagOpenContext> colgroupTagOpen() { 10749 return getRuleContexts(ColgroupTagOpenContext.class); 10750 } 10751 public ColgroupTagOpenContext colgroupTagOpen(int i) { 10752 return getRuleContext(ColgroupTagOpenContext.class,i); 10753 } 10754 public List<DdTagOpenContext> ddTagOpen() { 10755 return getRuleContexts(DdTagOpenContext.class); 10756 } 10757 public DdTagOpenContext ddTagOpen(int i) { 10758 return getRuleContext(DdTagOpenContext.class,i); 10759 } 10760 public List<DtTagOpenContext> dtTagOpen() { 10761 return getRuleContexts(DtTagOpenContext.class); 10762 } 10763 public DtTagOpenContext dtTagOpen(int i) { 10764 return getRuleContext(DtTagOpenContext.class,i); 10765 } 10766 public List<HeadTagOpenContext> headTagOpen() { 10767 return getRuleContexts(HeadTagOpenContext.class); 10768 } 10769 public HeadTagOpenContext headTagOpen(int i) { 10770 return getRuleContext(HeadTagOpenContext.class,i); 10771 } 10772 public List<HtmlTagOpenContext> htmlTagOpen() { 10773 return getRuleContexts(HtmlTagOpenContext.class); 10774 } 10775 public HtmlTagOpenContext htmlTagOpen(int i) { 10776 return getRuleContext(HtmlTagOpenContext.class,i); 10777 } 10778 public List<OptionTagOpenContext> optionTagOpen() { 10779 return getRuleContexts(OptionTagOpenContext.class); 10780 } 10781 public OptionTagOpenContext optionTagOpen(int i) { 10782 return getRuleContext(OptionTagOpenContext.class,i); 10783 } 10784 public List<TbodyTagOpenContext> tbodyTagOpen() { 10785 return getRuleContexts(TbodyTagOpenContext.class); 10786 } 10787 public TbodyTagOpenContext tbodyTagOpen(int i) { 10788 return getRuleContext(TbodyTagOpenContext.class,i); 10789 } 10790 public List<TheadTagOpenContext> theadTagOpen() { 10791 return getRuleContexts(TheadTagOpenContext.class); 10792 } 10793 public TheadTagOpenContext theadTagOpen(int i) { 10794 return getRuleContext(TheadTagOpenContext.class,i); 10795 } 10796 public List<HtmlCommentContext> htmlComment() { 10797 return getRuleContexts(HtmlCommentContext.class); 10798 } 10799 public HtmlCommentContext htmlComment(int i) { 10800 return getRuleContext(HtmlCommentContext.class,i); 10801 } 10802 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10803 public TerminalNode CDATA(int i) { 10804 return getToken(JavadocParser.CDATA, i); 10805 } 10806 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10807 public TerminalNode NEWLINE(int i) { 10808 return getToken(JavadocParser.NEWLINE, i); 10809 } 10810 public List<TextContext> text() { 10811 return getRuleContexts(TextContext.class); 10812 } 10813 public TextContext text(int i) { 10814 return getRuleContext(TextContext.class,i); 10815 } 10816 public List<JavadocInlineTagContext> javadocInlineTag() { 10817 return getRuleContexts(JavadocInlineTagContext.class); 10818 } 10819 public JavadocInlineTagContext javadocInlineTag(int i) { 10820 return getRuleContext(JavadocInlineTagContext.class,i); 10821 } 10822 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10823 public TerminalNode LEADING_ASTERISK(int i) { 10824 return getToken(JavadocParser.LEADING_ASTERISK, i); 10825 } 10826 public TfootContext(ParserRuleContext parent, int invokingState) { 10827 super(parent, invokingState); 10828 } 10829 @Override public int getRuleIndex() { return RULE_tfoot; } 10830 @Override 10831 public void enterRule(ParseTreeListener listener) { 10832 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfoot(this); 10833 } 10834 @Override 10835 public void exitRule(ParseTreeListener listener) { 10836 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfoot(this); 10837 } 10838 @Override 10839 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10840 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfoot(this); 10841 else return visitor.visitChildren(this); 10842 } 10843 } 10844 10845 public final TfootContext tfoot() throws RecognitionException { 10846 TfootContext _localctx = new TfootContext(_ctx, getState()); 10847 enterRule(_localctx, 94, RULE_tfoot); 10848 try { 10849 int _alt; 10850 enterOuterAlt(_localctx, 1); 10851 { 10852 setState(1227); 10853 tfootTagOpen(); 10854 setState(1267); 10855 _errHandler.sync(this); 10856 _alt = getInterpreter().adaptivePredict(_input,86,_ctx); 10857 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10858 if ( _alt==1 ) { 10859 { 10860 setState(1265); 10861 _errHandler.sync(this); 10862 switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) { 10863 case 1: 10864 { 10865 setState(1228); 10866 htmlTag(); 10867 } 10868 break; 10869 case 2: 10870 { 10871 setState(1229); 10872 singletonTag(); 10873 } 10874 break; 10875 case 3: 10876 { 10877 setState(1230); 10878 paragraph(); 10879 } 10880 break; 10881 case 4: 10882 { 10883 setState(1231); 10884 li(); 10885 } 10886 break; 10887 case 5: 10888 { 10889 setState(1232); 10890 tr(); 10891 } 10892 break; 10893 case 6: 10894 { 10895 setState(1233); 10896 td(); 10897 } 10898 break; 10899 case 7: 10900 { 10901 setState(1234); 10902 th(); 10903 } 10904 break; 10905 case 8: 10906 { 10907 setState(1235); 10908 body(); 10909 } 10910 break; 10911 case 9: 10912 { 10913 setState(1236); 10914 colgroup(); 10915 } 10916 break; 10917 case 10: 10918 { 10919 setState(1237); 10920 dd(); 10921 } 10922 break; 10923 case 11: 10924 { 10925 setState(1238); 10926 dt(); 10927 } 10928 break; 10929 case 12: 10930 { 10931 setState(1239); 10932 head(); 10933 } 10934 break; 10935 case 13: 10936 { 10937 setState(1240); 10938 html(); 10939 } 10940 break; 10941 case 14: 10942 { 10943 setState(1241); 10944 option(); 10945 } 10946 break; 10947 case 15: 10948 { 10949 setState(1242); 10950 tbody(); 10951 } 10952 break; 10953 case 16: 10954 { 10955 setState(1243); 10956 thead(); 10957 } 10958 break; 10959 case 17: 10960 { 10961 setState(1244); 10962 pTagOpen(); 10963 } 10964 break; 10965 case 18: 10966 { 10967 setState(1245); 10968 liTagOpen(); 10969 } 10970 break; 10971 case 19: 10972 { 10973 setState(1246); 10974 trTagOpen(); 10975 } 10976 break; 10977 case 20: 10978 { 10979 setState(1247); 10980 tdTagOpen(); 10981 } 10982 break; 10983 case 21: 10984 { 10985 setState(1248); 10986 thTagOpen(); 10987 } 10988 break; 10989 case 22: 10990 { 10991 setState(1249); 10992 bodyTagOpen(); 10993 } 10994 break; 10995 case 23: 10996 { 10997 setState(1250); 10998 colgroupTagOpen(); 10999 } 11000 break; 11001 case 24: 11002 { 11003 setState(1251); 11004 ddTagOpen(); 11005 } 11006 break; 11007 case 25: 11008 { 11009 setState(1252); 11010 dtTagOpen(); 11011 } 11012 break; 11013 case 26: 11014 { 11015 setState(1253); 11016 headTagOpen(); 11017 } 11018 break; 11019 case 27: 11020 { 11021 setState(1254); 11022 htmlTagOpen(); 11023 } 11024 break; 11025 case 28: 11026 { 11027 setState(1255); 11028 optionTagOpen(); 11029 } 11030 break; 11031 case 29: 11032 { 11033 setState(1256); 11034 tbodyTagOpen(); 11035 } 11036 break; 11037 case 30: 11038 { 11039 setState(1257); 11040 theadTagOpen(); 11041 } 11042 break; 11043 case 31: 11044 { 11045 { 11046 setState(1258); 11047 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 11048 setState(1259); 11049 match(LEADING_ASTERISK); 11050 } 11051 } 11052 break; 11053 case 32: 11054 { 11055 setState(1260); 11056 htmlComment(); 11057 } 11058 break; 11059 case 33: 11060 { 11061 setState(1261); 11062 match(CDATA); 11063 } 11064 break; 11065 case 34: 11066 { 11067 setState(1262); 11068 match(NEWLINE); 11069 } 11070 break; 11071 case 35: 11072 { 11073 setState(1263); 11074 text(); 11075 } 11076 break; 11077 case 36: 11078 { 11079 setState(1264); 11080 javadocInlineTag(); 11081 } 11082 break; 11083 } 11084 } 11085 } 11086 setState(1269); 11087 _errHandler.sync(this); 11088 _alt = getInterpreter().adaptivePredict(_input,86,_ctx); 11089 } 11090 setState(1270); 11091 tfootTagClose(); 11092 } 11093 } 11094 catch (RecognitionException re) { 11095 _localctx.exception = re; 11096 _errHandler.reportError(this, re); 11097 _errHandler.recover(this, re); 11098 } 11099 finally { 11100 exitRule(); 11101 } 11102 return _localctx; 11103 } 11104 11105 public static class TheadTagOpenContext extends ParserRuleContext { 11106 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11107 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11108 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11109 public List<AttributeContext> attribute() { 11110 return getRuleContexts(AttributeContext.class); 11111 } 11112 public AttributeContext attribute(int i) { 11113 return getRuleContext(AttributeContext.class,i); 11114 } 11115 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11116 public TerminalNode NEWLINE(int i) { 11117 return getToken(JavadocParser.NEWLINE, i); 11118 } 11119 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11120 public TerminalNode LEADING_ASTERISK(int i) { 11121 return getToken(JavadocParser.LEADING_ASTERISK, i); 11122 } 11123 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11124 public TerminalNode WS(int i) { 11125 return getToken(JavadocParser.WS, i); 11126 } 11127 public TheadTagOpenContext(ParserRuleContext parent, int invokingState) { 11128 super(parent, invokingState); 11129 } 11130 @Override public int getRuleIndex() { return RULE_theadTagOpen; } 11131 @Override 11132 public void enterRule(ParseTreeListener listener) { 11133 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagOpen(this); 11134 } 11135 @Override 11136 public void exitRule(ParseTreeListener listener) { 11137 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagOpen(this); 11138 } 11139 @Override 11140 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11141 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagOpen(this); 11142 else return visitor.visitChildren(this); 11143 } 11144 } 11145 11146 public final TheadTagOpenContext theadTagOpen() throws RecognitionException { 11147 TheadTagOpenContext _localctx = new TheadTagOpenContext(_ctx, getState()); 11148 enterRule(_localctx, 96, RULE_theadTagOpen); 11149 int _la; 11150 try { 11151 enterOuterAlt(_localctx, 1); 11152 { 11153 setState(1272); 11154 match(OPEN); 11155 setState(1273); 11156 match(THEAD_HTML_TAG_NAME); 11157 setState(1280); 11158 _errHandler.sync(this); 11159 _la = _input.LA(1); 11160 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11161 { 11162 setState(1278); 11163 _errHandler.sync(this); 11164 switch (_input.LA(1)) { 11165 case HTML_TAG_NAME: 11166 { 11167 setState(1274); 11168 attribute(); 11169 } 11170 break; 11171 case NEWLINE: 11172 { 11173 setState(1275); 11174 match(NEWLINE); 11175 } 11176 break; 11177 case LEADING_ASTERISK: 11178 { 11179 setState(1276); 11180 match(LEADING_ASTERISK); 11181 } 11182 break; 11183 case WS: 11184 { 11185 setState(1277); 11186 match(WS); 11187 } 11188 break; 11189 default: 11190 throw new NoViableAltException(this); 11191 } 11192 } 11193 setState(1282); 11194 _errHandler.sync(this); 11195 _la = _input.LA(1); 11196 } 11197 setState(1283); 11198 match(CLOSE); 11199 } 11200 } 11201 catch (RecognitionException re) { 11202 _localctx.exception = re; 11203 _errHandler.reportError(this, re); 11204 _errHandler.recover(this, re); 11205 } 11206 finally { 11207 exitRule(); 11208 } 11209 return _localctx; 11210 } 11211 11212 public static class TheadTagCloseContext extends ParserRuleContext { 11213 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11214 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 11215 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11216 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11217 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11218 public TerminalNode NEWLINE(int i) { 11219 return getToken(JavadocParser.NEWLINE, i); 11220 } 11221 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11222 public TerminalNode LEADING_ASTERISK(int i) { 11223 return getToken(JavadocParser.LEADING_ASTERISK, i); 11224 } 11225 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11226 public TerminalNode WS(int i) { 11227 return getToken(JavadocParser.WS, i); 11228 } 11229 public TheadTagCloseContext(ParserRuleContext parent, int invokingState) { 11230 super(parent, invokingState); 11231 } 11232 @Override public int getRuleIndex() { return RULE_theadTagClose; } 11233 @Override 11234 public void enterRule(ParseTreeListener listener) { 11235 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagClose(this); 11236 } 11237 @Override 11238 public void exitRule(ParseTreeListener listener) { 11239 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagClose(this); 11240 } 11241 @Override 11242 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11243 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagClose(this); 11244 else return visitor.visitChildren(this); 11245 } 11246 } 11247 11248 public final TheadTagCloseContext theadTagClose() throws RecognitionException { 11249 TheadTagCloseContext _localctx = new TheadTagCloseContext(_ctx, getState()); 11250 enterRule(_localctx, 98, RULE_theadTagClose); 11251 int _la; 11252 try { 11253 enterOuterAlt(_localctx, 1); 11254 { 11255 setState(1285); 11256 match(OPEN); 11257 setState(1286); 11258 match(SLASH); 11259 setState(1287); 11260 match(THEAD_HTML_TAG_NAME); 11261 setState(1291); 11262 _errHandler.sync(this); 11263 _la = _input.LA(1); 11264 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 11265 { 11266 { 11267 setState(1288); 11268 _la = _input.LA(1); 11269 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 11270 _errHandler.recoverInline(this); 11271 } 11272 else { 11273 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 11274 _errHandler.reportMatch(this); 11275 consume(); 11276 } 11277 } 11278 } 11279 setState(1293); 11280 _errHandler.sync(this); 11281 _la = _input.LA(1); 11282 } 11283 setState(1294); 11284 match(CLOSE); 11285 } 11286 } 11287 catch (RecognitionException re) { 11288 _localctx.exception = re; 11289 _errHandler.reportError(this, re); 11290 _errHandler.recover(this, re); 11291 } 11292 finally { 11293 exitRule(); 11294 } 11295 return _localctx; 11296 } 11297 11298 public static class TheadContext extends ParserRuleContext { 11299 public TheadTagOpenContext theadTagOpen() { 11300 return getRuleContext(TheadTagOpenContext.class,0); 11301 } 11302 public TheadTagCloseContext theadTagClose() { 11303 return getRuleContext(TheadTagCloseContext.class,0); 11304 } 11305 public List<HtmlTagContext> htmlTag() { 11306 return getRuleContexts(HtmlTagContext.class); 11307 } 11308 public HtmlTagContext htmlTag(int i) { 11309 return getRuleContext(HtmlTagContext.class,i); 11310 } 11311 public List<SingletonTagContext> singletonTag() { 11312 return getRuleContexts(SingletonTagContext.class); 11313 } 11314 public SingletonTagContext singletonTag(int i) { 11315 return getRuleContext(SingletonTagContext.class,i); 11316 } 11317 public List<ParagraphContext> paragraph() { 11318 return getRuleContexts(ParagraphContext.class); 11319 } 11320 public ParagraphContext paragraph(int i) { 11321 return getRuleContext(ParagraphContext.class,i); 11322 } 11323 public List<LiContext> li() { 11324 return getRuleContexts(LiContext.class); 11325 } 11326 public LiContext li(int i) { 11327 return getRuleContext(LiContext.class,i); 11328 } 11329 public List<TrContext> tr() { 11330 return getRuleContexts(TrContext.class); 11331 } 11332 public TrContext tr(int i) { 11333 return getRuleContext(TrContext.class,i); 11334 } 11335 public List<TdContext> td() { 11336 return getRuleContexts(TdContext.class); 11337 } 11338 public TdContext td(int i) { 11339 return getRuleContext(TdContext.class,i); 11340 } 11341 public List<ThContext> th() { 11342 return getRuleContexts(ThContext.class); 11343 } 11344 public ThContext th(int i) { 11345 return getRuleContext(ThContext.class,i); 11346 } 11347 public List<BodyContext> body() { 11348 return getRuleContexts(BodyContext.class); 11349 } 11350 public BodyContext body(int i) { 11351 return getRuleContext(BodyContext.class,i); 11352 } 11353 public List<ColgroupContext> colgroup() { 11354 return getRuleContexts(ColgroupContext.class); 11355 } 11356 public ColgroupContext colgroup(int i) { 11357 return getRuleContext(ColgroupContext.class,i); 11358 } 11359 public List<DdContext> dd() { 11360 return getRuleContexts(DdContext.class); 11361 } 11362 public DdContext dd(int i) { 11363 return getRuleContext(DdContext.class,i); 11364 } 11365 public List<DtContext> dt() { 11366 return getRuleContexts(DtContext.class); 11367 } 11368 public DtContext dt(int i) { 11369 return getRuleContext(DtContext.class,i); 11370 } 11371 public List<HeadContext> head() { 11372 return getRuleContexts(HeadContext.class); 11373 } 11374 public HeadContext head(int i) { 11375 return getRuleContext(HeadContext.class,i); 11376 } 11377 public List<HtmlContext> html() { 11378 return getRuleContexts(HtmlContext.class); 11379 } 11380 public HtmlContext html(int i) { 11381 return getRuleContext(HtmlContext.class,i); 11382 } 11383 public List<OptionContext> option() { 11384 return getRuleContexts(OptionContext.class); 11385 } 11386 public OptionContext option(int i) { 11387 return getRuleContext(OptionContext.class,i); 11388 } 11389 public List<TbodyContext> tbody() { 11390 return getRuleContexts(TbodyContext.class); 11391 } 11392 public TbodyContext tbody(int i) { 11393 return getRuleContext(TbodyContext.class,i); 11394 } 11395 public List<TfootContext> tfoot() { 11396 return getRuleContexts(TfootContext.class); 11397 } 11398 public TfootContext tfoot(int i) { 11399 return getRuleContext(TfootContext.class,i); 11400 } 11401 public List<PTagOpenContext> pTagOpen() { 11402 return getRuleContexts(PTagOpenContext.class); 11403 } 11404 public PTagOpenContext pTagOpen(int i) { 11405 return getRuleContext(PTagOpenContext.class,i); 11406 } 11407 public List<LiTagOpenContext> liTagOpen() { 11408 return getRuleContexts(LiTagOpenContext.class); 11409 } 11410 public LiTagOpenContext liTagOpen(int i) { 11411 return getRuleContext(LiTagOpenContext.class,i); 11412 } 11413 public List<TrTagOpenContext> trTagOpen() { 11414 return getRuleContexts(TrTagOpenContext.class); 11415 } 11416 public TrTagOpenContext trTagOpen(int i) { 11417 return getRuleContext(TrTagOpenContext.class,i); 11418 } 11419 public List<TdTagOpenContext> tdTagOpen() { 11420 return getRuleContexts(TdTagOpenContext.class); 11421 } 11422 public TdTagOpenContext tdTagOpen(int i) { 11423 return getRuleContext(TdTagOpenContext.class,i); 11424 } 11425 public List<ThTagOpenContext> thTagOpen() { 11426 return getRuleContexts(ThTagOpenContext.class); 11427 } 11428 public ThTagOpenContext thTagOpen(int i) { 11429 return getRuleContext(ThTagOpenContext.class,i); 11430 } 11431 public List<BodyTagOpenContext> bodyTagOpen() { 11432 return getRuleContexts(BodyTagOpenContext.class); 11433 } 11434 public BodyTagOpenContext bodyTagOpen(int i) { 11435 return getRuleContext(BodyTagOpenContext.class,i); 11436 } 11437 public List<ColgroupTagOpenContext> colgroupTagOpen() { 11438 return getRuleContexts(ColgroupTagOpenContext.class); 11439 } 11440 public ColgroupTagOpenContext colgroupTagOpen(int i) { 11441 return getRuleContext(ColgroupTagOpenContext.class,i); 11442 } 11443 public List<DdTagOpenContext> ddTagOpen() { 11444 return getRuleContexts(DdTagOpenContext.class); 11445 } 11446 public DdTagOpenContext ddTagOpen(int i) { 11447 return getRuleContext(DdTagOpenContext.class,i); 11448 } 11449 public List<DtTagOpenContext> dtTagOpen() { 11450 return getRuleContexts(DtTagOpenContext.class); 11451 } 11452 public DtTagOpenContext dtTagOpen(int i) { 11453 return getRuleContext(DtTagOpenContext.class,i); 11454 } 11455 public List<HeadTagOpenContext> headTagOpen() { 11456 return getRuleContexts(HeadTagOpenContext.class); 11457 } 11458 public HeadTagOpenContext headTagOpen(int i) { 11459 return getRuleContext(HeadTagOpenContext.class,i); 11460 } 11461 public List<HtmlTagOpenContext> htmlTagOpen() { 11462 return getRuleContexts(HtmlTagOpenContext.class); 11463 } 11464 public HtmlTagOpenContext htmlTagOpen(int i) { 11465 return getRuleContext(HtmlTagOpenContext.class,i); 11466 } 11467 public List<OptionTagOpenContext> optionTagOpen() { 11468 return getRuleContexts(OptionTagOpenContext.class); 11469 } 11470 public OptionTagOpenContext optionTagOpen(int i) { 11471 return getRuleContext(OptionTagOpenContext.class,i); 11472 } 11473 public List<TbodyTagOpenContext> tbodyTagOpen() { 11474 return getRuleContexts(TbodyTagOpenContext.class); 11475 } 11476 public TbodyTagOpenContext tbodyTagOpen(int i) { 11477 return getRuleContext(TbodyTagOpenContext.class,i); 11478 } 11479 public List<TfootTagOpenContext> tfootTagOpen() { 11480 return getRuleContexts(TfootTagOpenContext.class); 11481 } 11482 public TfootTagOpenContext tfootTagOpen(int i) { 11483 return getRuleContext(TfootTagOpenContext.class,i); 11484 } 11485 public List<HtmlCommentContext> htmlComment() { 11486 return getRuleContexts(HtmlCommentContext.class); 11487 } 11488 public HtmlCommentContext htmlComment(int i) { 11489 return getRuleContext(HtmlCommentContext.class,i); 11490 } 11491 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 11492 public TerminalNode CDATA(int i) { 11493 return getToken(JavadocParser.CDATA, i); 11494 } 11495 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11496 public TerminalNode NEWLINE(int i) { 11497 return getToken(JavadocParser.NEWLINE, i); 11498 } 11499 public List<TextContext> text() { 11500 return getRuleContexts(TextContext.class); 11501 } 11502 public TextContext text(int i) { 11503 return getRuleContext(TextContext.class,i); 11504 } 11505 public List<JavadocInlineTagContext> javadocInlineTag() { 11506 return getRuleContexts(JavadocInlineTagContext.class); 11507 } 11508 public JavadocInlineTagContext javadocInlineTag(int i) { 11509 return getRuleContext(JavadocInlineTagContext.class,i); 11510 } 11511 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11512 public TerminalNode LEADING_ASTERISK(int i) { 11513 return getToken(JavadocParser.LEADING_ASTERISK, i); 11514 } 11515 public TheadContext(ParserRuleContext parent, int invokingState) { 11516 super(parent, invokingState); 11517 } 11518 @Override public int getRuleIndex() { return RULE_thead; } 11519 @Override 11520 public void enterRule(ParseTreeListener listener) { 11521 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThead(this); 11522 } 11523 @Override 11524 public void exitRule(ParseTreeListener listener) { 11525 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThead(this); 11526 } 11527 @Override 11528 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11529 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThead(this); 11530 else return visitor.visitChildren(this); 11531 } 11532 } 11533 11534 public final TheadContext thead() throws RecognitionException { 11535 TheadContext _localctx = new TheadContext(_ctx, getState()); 11536 enterRule(_localctx, 100, RULE_thead); 11537 try { 11538 int _alt; 11539 enterOuterAlt(_localctx, 1); 11540 { 11541 setState(1296); 11542 theadTagOpen(); 11543 setState(1336); 11544 _errHandler.sync(this); 11545 _alt = getInterpreter().adaptivePredict(_input,91,_ctx); 11546 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 11547 if ( _alt==1 ) { 11548 { 11549 setState(1334); 11550 _errHandler.sync(this); 11551 switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) { 11552 case 1: 11553 { 11554 setState(1297); 11555 htmlTag(); 11556 } 11557 break; 11558 case 2: 11559 { 11560 setState(1298); 11561 singletonTag(); 11562 } 11563 break; 11564 case 3: 11565 { 11566 setState(1299); 11567 paragraph(); 11568 } 11569 break; 11570 case 4: 11571 { 11572 setState(1300); 11573 li(); 11574 } 11575 break; 11576 case 5: 11577 { 11578 setState(1301); 11579 tr(); 11580 } 11581 break; 11582 case 6: 11583 { 11584 setState(1302); 11585 td(); 11586 } 11587 break; 11588 case 7: 11589 { 11590 setState(1303); 11591 th(); 11592 } 11593 break; 11594 case 8: 11595 { 11596 setState(1304); 11597 body(); 11598 } 11599 break; 11600 case 9: 11601 { 11602 setState(1305); 11603 colgroup(); 11604 } 11605 break; 11606 case 10: 11607 { 11608 setState(1306); 11609 dd(); 11610 } 11611 break; 11612 case 11: 11613 { 11614 setState(1307); 11615 dt(); 11616 } 11617 break; 11618 case 12: 11619 { 11620 setState(1308); 11621 head(); 11622 } 11623 break; 11624 case 13: 11625 { 11626 setState(1309); 11627 html(); 11628 } 11629 break; 11630 case 14: 11631 { 11632 setState(1310); 11633 option(); 11634 } 11635 break; 11636 case 15: 11637 { 11638 setState(1311); 11639 tbody(); 11640 } 11641 break; 11642 case 16: 11643 { 11644 setState(1312); 11645 tfoot(); 11646 } 11647 break; 11648 case 17: 11649 { 11650 setState(1313); 11651 pTagOpen(); 11652 } 11653 break; 11654 case 18: 11655 { 11656 setState(1314); 11657 liTagOpen(); 11658 } 11659 break; 11660 case 19: 11661 { 11662 setState(1315); 11663 trTagOpen(); 11664 } 11665 break; 11666 case 20: 11667 { 11668 setState(1316); 11669 tdTagOpen(); 11670 } 11671 break; 11672 case 21: 11673 { 11674 setState(1317); 11675 thTagOpen(); 11676 } 11677 break; 11678 case 22: 11679 { 11680 setState(1318); 11681 bodyTagOpen(); 11682 } 11683 break; 11684 case 23: 11685 { 11686 setState(1319); 11687 colgroupTagOpen(); 11688 } 11689 break; 11690 case 24: 11691 { 11692 setState(1320); 11693 ddTagOpen(); 11694 } 11695 break; 11696 case 25: 11697 { 11698 setState(1321); 11699 dtTagOpen(); 11700 } 11701 break; 11702 case 26: 11703 { 11704 setState(1322); 11705 headTagOpen(); 11706 } 11707 break; 11708 case 27: 11709 { 11710 setState(1323); 11711 htmlTagOpen(); 11712 } 11713 break; 11714 case 28: 11715 { 11716 setState(1324); 11717 optionTagOpen(); 11718 } 11719 break; 11720 case 29: 11721 { 11722 setState(1325); 11723 tbodyTagOpen(); 11724 } 11725 break; 11726 case 30: 11727 { 11728 setState(1326); 11729 tfootTagOpen(); 11730 } 11731 break; 11732 case 31: 11733 { 11734 { 11735 setState(1327); 11736 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 11737 setState(1328); 11738 match(LEADING_ASTERISK); 11739 } 11740 } 11741 break; 11742 case 32: 11743 { 11744 setState(1329); 11745 htmlComment(); 11746 } 11747 break; 11748 case 33: 11749 { 11750 setState(1330); 11751 match(CDATA); 11752 } 11753 break; 11754 case 34: 11755 { 11756 setState(1331); 11757 match(NEWLINE); 11758 } 11759 break; 11760 case 35: 11761 { 11762 setState(1332); 11763 text(); 11764 } 11765 break; 11766 case 36: 11767 { 11768 setState(1333); 11769 javadocInlineTag(); 11770 } 11771 break; 11772 } 11773 } 11774 } 11775 setState(1338); 11776 _errHandler.sync(this); 11777 _alt = getInterpreter().adaptivePredict(_input,91,_ctx); 11778 } 11779 setState(1339); 11780 theadTagClose(); 11781 } 11782 } 11783 catch (RecognitionException re) { 11784 _localctx.exception = re; 11785 _errHandler.reportError(this, re); 11786 _errHandler.recover(this, re); 11787 } 11788 finally { 11789 exitRule(); 11790 } 11791 return _localctx; 11792 } 11793 11794 public static class SingletonElementContext extends ParserRuleContext { 11795 public SingletonTagContext singletonTag() { 11796 return getRuleContext(SingletonTagContext.class,0); 11797 } 11798 public AreaTagContext areaTag() { 11799 return getRuleContext(AreaTagContext.class,0); 11800 } 11801 public BaseTagContext baseTag() { 11802 return getRuleContext(BaseTagContext.class,0); 11803 } 11804 public BasefontTagContext basefontTag() { 11805 return getRuleContext(BasefontTagContext.class,0); 11806 } 11807 public BrTagContext brTag() { 11808 return getRuleContext(BrTagContext.class,0); 11809 } 11810 public ColTagContext colTag() { 11811 return getRuleContext(ColTagContext.class,0); 11812 } 11813 public FrameTagContext frameTag() { 11814 return getRuleContext(FrameTagContext.class,0); 11815 } 11816 public HrTagContext hrTag() { 11817 return getRuleContext(HrTagContext.class,0); 11818 } 11819 public ImgTagContext imgTag() { 11820 return getRuleContext(ImgTagContext.class,0); 11821 } 11822 public InputTagContext inputTag() { 11823 return getRuleContext(InputTagContext.class,0); 11824 } 11825 public IsindexTagContext isindexTag() { 11826 return getRuleContext(IsindexTagContext.class,0); 11827 } 11828 public LinkTagContext linkTag() { 11829 return getRuleContext(LinkTagContext.class,0); 11830 } 11831 public MetaTagContext metaTag() { 11832 return getRuleContext(MetaTagContext.class,0); 11833 } 11834 public ParamTagContext paramTag() { 11835 return getRuleContext(ParamTagContext.class,0); 11836 } 11837 public WrongSinletonTagContext wrongSinletonTag() { 11838 return getRuleContext(WrongSinletonTagContext.class,0); 11839 } 11840 public SingletonElementContext(ParserRuleContext parent, int invokingState) { 11841 super(parent, invokingState); 11842 } 11843 @Override public int getRuleIndex() { return RULE_singletonElement; } 11844 @Override 11845 public void enterRule(ParseTreeListener listener) { 11846 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonElement(this); 11847 } 11848 @Override 11849 public void exitRule(ParseTreeListener listener) { 11850 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonElement(this); 11851 } 11852 @Override 11853 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11854 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonElement(this); 11855 else return visitor.visitChildren(this); 11856 } 11857 } 11858 11859 public final SingletonElementContext singletonElement() throws RecognitionException { 11860 SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState()); 11861 enterRule(_localctx, 102, RULE_singletonElement); 11862 try { 11863 setState(1356); 11864 _errHandler.sync(this); 11865 switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) { 11866 case 1: 11867 enterOuterAlt(_localctx, 1); 11868 { 11869 setState(1341); 11870 singletonTag(); 11871 } 11872 break; 11873 case 2: 11874 enterOuterAlt(_localctx, 2); 11875 { 11876 setState(1342); 11877 areaTag(); 11878 } 11879 break; 11880 case 3: 11881 enterOuterAlt(_localctx, 3); 11882 { 11883 setState(1343); 11884 baseTag(); 11885 } 11886 break; 11887 case 4: 11888 enterOuterAlt(_localctx, 4); 11889 { 11890 setState(1344); 11891 basefontTag(); 11892 } 11893 break; 11894 case 5: 11895 enterOuterAlt(_localctx, 5); 11896 { 11897 setState(1345); 11898 brTag(); 11899 } 11900 break; 11901 case 6: 11902 enterOuterAlt(_localctx, 6); 11903 { 11904 setState(1346); 11905 colTag(); 11906 } 11907 break; 11908 case 7: 11909 enterOuterAlt(_localctx, 7); 11910 { 11911 setState(1347); 11912 frameTag(); 11913 } 11914 break; 11915 case 8: 11916 enterOuterAlt(_localctx, 8); 11917 { 11918 setState(1348); 11919 hrTag(); 11920 } 11921 break; 11922 case 9: 11923 enterOuterAlt(_localctx, 9); 11924 { 11925 setState(1349); 11926 imgTag(); 11927 } 11928 break; 11929 case 10: 11930 enterOuterAlt(_localctx, 10); 11931 { 11932 setState(1350); 11933 inputTag(); 11934 } 11935 break; 11936 case 11: 11937 enterOuterAlt(_localctx, 11); 11938 { 11939 setState(1351); 11940 isindexTag(); 11941 } 11942 break; 11943 case 12: 11944 enterOuterAlt(_localctx, 12); 11945 { 11946 setState(1352); 11947 linkTag(); 11948 } 11949 break; 11950 case 13: 11951 enterOuterAlt(_localctx, 13); 11952 { 11953 setState(1353); 11954 metaTag(); 11955 } 11956 break; 11957 case 14: 11958 enterOuterAlt(_localctx, 14); 11959 { 11960 setState(1354); 11961 paramTag(); 11962 } 11963 break; 11964 case 15: 11965 enterOuterAlt(_localctx, 15); 11966 { 11967 setState(1355); 11968 wrongSinletonTag(); 11969 } 11970 break; 11971 } 11972 } 11973 catch (RecognitionException re) { 11974 _localctx.exception = re; 11975 _errHandler.reportError(this, re); 11976 _errHandler.recover(this, re); 11977 } 11978 finally { 11979 exitRule(); 11980 } 11981 return _localctx; 11982 } 11983 11984 public static class SingletonTagContext extends ParserRuleContext { 11985 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11986 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 11987 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 11988 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 11989 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 11990 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 11991 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 11992 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 11993 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 11994 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 11995 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 11996 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 11997 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 11998 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 11999 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 12000 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 12001 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 12002 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 12003 public List<AttributeContext> attribute() { 12004 return getRuleContexts(AttributeContext.class); 12005 } 12006 public AttributeContext attribute(int i) { 12007 return getRuleContext(AttributeContext.class,i); 12008 } 12009 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12010 public TerminalNode NEWLINE(int i) { 12011 return getToken(JavadocParser.NEWLINE, i); 12012 } 12013 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12014 public TerminalNode LEADING_ASTERISK(int i) { 12015 return getToken(JavadocParser.LEADING_ASTERISK, i); 12016 } 12017 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12018 public TerminalNode WS(int i) { 12019 return getToken(JavadocParser.WS, i); 12020 } 12021 public SingletonTagContext(ParserRuleContext parent, int invokingState) { 12022 super(parent, invokingState); 12023 } 12024 @Override public int getRuleIndex() { return RULE_singletonTag; } 12025 @Override 12026 public void enterRule(ParseTreeListener listener) { 12027 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTag(this); 12028 } 12029 @Override 12030 public void exitRule(ParseTreeListener listener) { 12031 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTag(this); 12032 } 12033 @Override 12034 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12035 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTag(this); 12036 else return visitor.visitChildren(this); 12037 } 12038 } 12039 12040 public final SingletonTagContext singletonTag() throws RecognitionException { 12041 SingletonTagContext _localctx = new SingletonTagContext(_ctx, getState()); 12042 enterRule(_localctx, 104, RULE_singletonTag); 12043 int _la; 12044 try { 12045 enterOuterAlt(_localctx, 1); 12046 { 12047 setState(1358); 12048 match(OPEN); 12049 setState(1359); 12050 _la = _input.LA(1); 12051 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)) ) { 12052 _errHandler.recoverInline(this); 12053 } 12054 else { 12055 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12056 _errHandler.reportMatch(this); 12057 consume(); 12058 } 12059 setState(1366); 12060 _errHandler.sync(this); 12061 _la = _input.LA(1); 12062 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12063 { 12064 setState(1364); 12065 _errHandler.sync(this); 12066 switch (_input.LA(1)) { 12067 case HTML_TAG_NAME: 12068 { 12069 setState(1360); 12070 attribute(); 12071 } 12072 break; 12073 case NEWLINE: 12074 { 12075 setState(1361); 12076 match(NEWLINE); 12077 } 12078 break; 12079 case LEADING_ASTERISK: 12080 { 12081 setState(1362); 12082 match(LEADING_ASTERISK); 12083 } 12084 break; 12085 case WS: 12086 { 12087 setState(1363); 12088 match(WS); 12089 } 12090 break; 12091 default: 12092 throw new NoViableAltException(this); 12093 } 12094 } 12095 setState(1368); 12096 _errHandler.sync(this); 12097 _la = _input.LA(1); 12098 } 12099 setState(1369); 12100 match(SLASH_CLOSE); 12101 } 12102 } 12103 catch (RecognitionException re) { 12104 _localctx.exception = re; 12105 _errHandler.reportError(this, re); 12106 _errHandler.recover(this, re); 12107 } 12108 finally { 12109 exitRule(); 12110 } 12111 return _localctx; 12112 } 12113 12114 public static class AreaTagContext extends ParserRuleContext { 12115 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12116 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 12117 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12118 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12119 public List<AttributeContext> attribute() { 12120 return getRuleContexts(AttributeContext.class); 12121 } 12122 public AttributeContext attribute(int i) { 12123 return getRuleContext(AttributeContext.class,i); 12124 } 12125 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12126 public TerminalNode NEWLINE(int i) { 12127 return getToken(JavadocParser.NEWLINE, i); 12128 } 12129 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12130 public TerminalNode LEADING_ASTERISK(int i) { 12131 return getToken(JavadocParser.LEADING_ASTERISK, i); 12132 } 12133 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12134 public TerminalNode WS(int i) { 12135 return getToken(JavadocParser.WS, i); 12136 } 12137 public AreaTagContext(ParserRuleContext parent, int invokingState) { 12138 super(parent, invokingState); 12139 } 12140 @Override public int getRuleIndex() { return RULE_areaTag; } 12141 @Override 12142 public void enterRule(ParseTreeListener listener) { 12143 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAreaTag(this); 12144 } 12145 @Override 12146 public void exitRule(ParseTreeListener listener) { 12147 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAreaTag(this); 12148 } 12149 @Override 12150 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12151 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAreaTag(this); 12152 else return visitor.visitChildren(this); 12153 } 12154 } 12155 12156 public final AreaTagContext areaTag() throws RecognitionException { 12157 AreaTagContext _localctx = new AreaTagContext(_ctx, getState()); 12158 enterRule(_localctx, 106, RULE_areaTag); 12159 int _la; 12160 try { 12161 enterOuterAlt(_localctx, 1); 12162 { 12163 setState(1371); 12164 match(OPEN); 12165 setState(1372); 12166 match(AREA_HTML_TAG_NAME); 12167 setState(1379); 12168 _errHandler.sync(this); 12169 _la = _input.LA(1); 12170 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12171 { 12172 setState(1377); 12173 _errHandler.sync(this); 12174 switch (_input.LA(1)) { 12175 case HTML_TAG_NAME: 12176 { 12177 setState(1373); 12178 attribute(); 12179 } 12180 break; 12181 case NEWLINE: 12182 { 12183 setState(1374); 12184 match(NEWLINE); 12185 } 12186 break; 12187 case LEADING_ASTERISK: 12188 { 12189 setState(1375); 12190 match(LEADING_ASTERISK); 12191 } 12192 break; 12193 case WS: 12194 { 12195 setState(1376); 12196 match(WS); 12197 } 12198 break; 12199 default: 12200 throw new NoViableAltException(this); 12201 } 12202 } 12203 setState(1381); 12204 _errHandler.sync(this); 12205 _la = _input.LA(1); 12206 } 12207 setState(1382); 12208 _la = _input.LA(1); 12209 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12210 _errHandler.recoverInline(this); 12211 } 12212 else { 12213 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12214 _errHandler.reportMatch(this); 12215 consume(); 12216 } 12217 } 12218 } 12219 catch (RecognitionException re) { 12220 _localctx.exception = re; 12221 _errHandler.reportError(this, re); 12222 _errHandler.recover(this, re); 12223 } 12224 finally { 12225 exitRule(); 12226 } 12227 return _localctx; 12228 } 12229 12230 public static class BaseTagContext extends ParserRuleContext { 12231 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12232 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 12233 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12234 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12235 public List<AttributeContext> attribute() { 12236 return getRuleContexts(AttributeContext.class); 12237 } 12238 public AttributeContext attribute(int i) { 12239 return getRuleContext(AttributeContext.class,i); 12240 } 12241 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12242 public TerminalNode NEWLINE(int i) { 12243 return getToken(JavadocParser.NEWLINE, i); 12244 } 12245 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12246 public TerminalNode LEADING_ASTERISK(int i) { 12247 return getToken(JavadocParser.LEADING_ASTERISK, i); 12248 } 12249 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12250 public TerminalNode WS(int i) { 12251 return getToken(JavadocParser.WS, i); 12252 } 12253 public BaseTagContext(ParserRuleContext parent, int invokingState) { 12254 super(parent, invokingState); 12255 } 12256 @Override public int getRuleIndex() { return RULE_baseTag; } 12257 @Override 12258 public void enterRule(ParseTreeListener listener) { 12259 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBaseTag(this); 12260 } 12261 @Override 12262 public void exitRule(ParseTreeListener listener) { 12263 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBaseTag(this); 12264 } 12265 @Override 12266 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12267 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBaseTag(this); 12268 else return visitor.visitChildren(this); 12269 } 12270 } 12271 12272 public final BaseTagContext baseTag() throws RecognitionException { 12273 BaseTagContext _localctx = new BaseTagContext(_ctx, getState()); 12274 enterRule(_localctx, 108, RULE_baseTag); 12275 int _la; 12276 try { 12277 enterOuterAlt(_localctx, 1); 12278 { 12279 setState(1384); 12280 match(OPEN); 12281 setState(1385); 12282 match(BASE_HTML_TAG_NAME); 12283 setState(1392); 12284 _errHandler.sync(this); 12285 _la = _input.LA(1); 12286 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12287 { 12288 setState(1390); 12289 _errHandler.sync(this); 12290 switch (_input.LA(1)) { 12291 case HTML_TAG_NAME: 12292 { 12293 setState(1386); 12294 attribute(); 12295 } 12296 break; 12297 case NEWLINE: 12298 { 12299 setState(1387); 12300 match(NEWLINE); 12301 } 12302 break; 12303 case LEADING_ASTERISK: 12304 { 12305 setState(1388); 12306 match(LEADING_ASTERISK); 12307 } 12308 break; 12309 case WS: 12310 { 12311 setState(1389); 12312 match(WS); 12313 } 12314 break; 12315 default: 12316 throw new NoViableAltException(this); 12317 } 12318 } 12319 setState(1394); 12320 _errHandler.sync(this); 12321 _la = _input.LA(1); 12322 } 12323 setState(1395); 12324 _la = _input.LA(1); 12325 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12326 _errHandler.recoverInline(this); 12327 } 12328 else { 12329 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12330 _errHandler.reportMatch(this); 12331 consume(); 12332 } 12333 } 12334 } 12335 catch (RecognitionException re) { 12336 _localctx.exception = re; 12337 _errHandler.reportError(this, re); 12338 _errHandler.recover(this, re); 12339 } 12340 finally { 12341 exitRule(); 12342 } 12343 return _localctx; 12344 } 12345 12346 public static class BasefontTagContext extends ParserRuleContext { 12347 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12348 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 12349 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12350 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12351 public List<AttributeContext> attribute() { 12352 return getRuleContexts(AttributeContext.class); 12353 } 12354 public AttributeContext attribute(int i) { 12355 return getRuleContext(AttributeContext.class,i); 12356 } 12357 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12358 public TerminalNode NEWLINE(int i) { 12359 return getToken(JavadocParser.NEWLINE, i); 12360 } 12361 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12362 public TerminalNode LEADING_ASTERISK(int i) { 12363 return getToken(JavadocParser.LEADING_ASTERISK, i); 12364 } 12365 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12366 public TerminalNode WS(int i) { 12367 return getToken(JavadocParser.WS, i); 12368 } 12369 public BasefontTagContext(ParserRuleContext parent, int invokingState) { 12370 super(parent, invokingState); 12371 } 12372 @Override public int getRuleIndex() { return RULE_basefontTag; } 12373 @Override 12374 public void enterRule(ParseTreeListener listener) { 12375 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBasefontTag(this); 12376 } 12377 @Override 12378 public void exitRule(ParseTreeListener listener) { 12379 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBasefontTag(this); 12380 } 12381 @Override 12382 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12383 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBasefontTag(this); 12384 else return visitor.visitChildren(this); 12385 } 12386 } 12387 12388 public final BasefontTagContext basefontTag() throws RecognitionException { 12389 BasefontTagContext _localctx = new BasefontTagContext(_ctx, getState()); 12390 enterRule(_localctx, 110, RULE_basefontTag); 12391 int _la; 12392 try { 12393 enterOuterAlt(_localctx, 1); 12394 { 12395 setState(1397); 12396 match(OPEN); 12397 setState(1398); 12398 match(BASEFONT_HTML_TAG_NAME); 12399 setState(1405); 12400 _errHandler.sync(this); 12401 _la = _input.LA(1); 12402 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12403 { 12404 setState(1403); 12405 _errHandler.sync(this); 12406 switch (_input.LA(1)) { 12407 case HTML_TAG_NAME: 12408 { 12409 setState(1399); 12410 attribute(); 12411 } 12412 break; 12413 case NEWLINE: 12414 { 12415 setState(1400); 12416 match(NEWLINE); 12417 } 12418 break; 12419 case LEADING_ASTERISK: 12420 { 12421 setState(1401); 12422 match(LEADING_ASTERISK); 12423 } 12424 break; 12425 case WS: 12426 { 12427 setState(1402); 12428 match(WS); 12429 } 12430 break; 12431 default: 12432 throw new NoViableAltException(this); 12433 } 12434 } 12435 setState(1407); 12436 _errHandler.sync(this); 12437 _la = _input.LA(1); 12438 } 12439 setState(1408); 12440 _la = _input.LA(1); 12441 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12442 _errHandler.recoverInline(this); 12443 } 12444 else { 12445 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12446 _errHandler.reportMatch(this); 12447 consume(); 12448 } 12449 } 12450 } 12451 catch (RecognitionException re) { 12452 _localctx.exception = re; 12453 _errHandler.reportError(this, re); 12454 _errHandler.recover(this, re); 12455 } 12456 finally { 12457 exitRule(); 12458 } 12459 return _localctx; 12460 } 12461 12462 public static class BrTagContext extends ParserRuleContext { 12463 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12464 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 12465 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12466 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12467 public List<AttributeContext> attribute() { 12468 return getRuleContexts(AttributeContext.class); 12469 } 12470 public AttributeContext attribute(int i) { 12471 return getRuleContext(AttributeContext.class,i); 12472 } 12473 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12474 public TerminalNode NEWLINE(int i) { 12475 return getToken(JavadocParser.NEWLINE, i); 12476 } 12477 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12478 public TerminalNode LEADING_ASTERISK(int i) { 12479 return getToken(JavadocParser.LEADING_ASTERISK, i); 12480 } 12481 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12482 public TerminalNode WS(int i) { 12483 return getToken(JavadocParser.WS, i); 12484 } 12485 public BrTagContext(ParserRuleContext parent, int invokingState) { 12486 super(parent, invokingState); 12487 } 12488 @Override public int getRuleIndex() { return RULE_brTag; } 12489 @Override 12490 public void enterRule(ParseTreeListener listener) { 12491 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBrTag(this); 12492 } 12493 @Override 12494 public void exitRule(ParseTreeListener listener) { 12495 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBrTag(this); 12496 } 12497 @Override 12498 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12499 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBrTag(this); 12500 else return visitor.visitChildren(this); 12501 } 12502 } 12503 12504 public final BrTagContext brTag() throws RecognitionException { 12505 BrTagContext _localctx = new BrTagContext(_ctx, getState()); 12506 enterRule(_localctx, 112, RULE_brTag); 12507 int _la; 12508 try { 12509 enterOuterAlt(_localctx, 1); 12510 { 12511 setState(1410); 12512 match(OPEN); 12513 setState(1411); 12514 match(BR_HTML_TAG_NAME); 12515 setState(1418); 12516 _errHandler.sync(this); 12517 _la = _input.LA(1); 12518 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12519 { 12520 setState(1416); 12521 _errHandler.sync(this); 12522 switch (_input.LA(1)) { 12523 case HTML_TAG_NAME: 12524 { 12525 setState(1412); 12526 attribute(); 12527 } 12528 break; 12529 case NEWLINE: 12530 { 12531 setState(1413); 12532 match(NEWLINE); 12533 } 12534 break; 12535 case LEADING_ASTERISK: 12536 { 12537 setState(1414); 12538 match(LEADING_ASTERISK); 12539 } 12540 break; 12541 case WS: 12542 { 12543 setState(1415); 12544 match(WS); 12545 } 12546 break; 12547 default: 12548 throw new NoViableAltException(this); 12549 } 12550 } 12551 setState(1420); 12552 _errHandler.sync(this); 12553 _la = _input.LA(1); 12554 } 12555 setState(1421); 12556 _la = _input.LA(1); 12557 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12558 _errHandler.recoverInline(this); 12559 } 12560 else { 12561 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12562 _errHandler.reportMatch(this); 12563 consume(); 12564 } 12565 } 12566 } 12567 catch (RecognitionException re) { 12568 _localctx.exception = re; 12569 _errHandler.reportError(this, re); 12570 _errHandler.recover(this, re); 12571 } 12572 finally { 12573 exitRule(); 12574 } 12575 return _localctx; 12576 } 12577 12578 public static class ColTagContext extends ParserRuleContext { 12579 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12580 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 12581 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12582 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12583 public List<AttributeContext> attribute() { 12584 return getRuleContexts(AttributeContext.class); 12585 } 12586 public AttributeContext attribute(int i) { 12587 return getRuleContext(AttributeContext.class,i); 12588 } 12589 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12590 public TerminalNode NEWLINE(int i) { 12591 return getToken(JavadocParser.NEWLINE, i); 12592 } 12593 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12594 public TerminalNode LEADING_ASTERISK(int i) { 12595 return getToken(JavadocParser.LEADING_ASTERISK, i); 12596 } 12597 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12598 public TerminalNode WS(int i) { 12599 return getToken(JavadocParser.WS, i); 12600 } 12601 public ColTagContext(ParserRuleContext parent, int invokingState) { 12602 super(parent, invokingState); 12603 } 12604 @Override public int getRuleIndex() { return RULE_colTag; } 12605 @Override 12606 public void enterRule(ParseTreeListener listener) { 12607 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColTag(this); 12608 } 12609 @Override 12610 public void exitRule(ParseTreeListener listener) { 12611 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColTag(this); 12612 } 12613 @Override 12614 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12615 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColTag(this); 12616 else return visitor.visitChildren(this); 12617 } 12618 } 12619 12620 public final ColTagContext colTag() throws RecognitionException { 12621 ColTagContext _localctx = new ColTagContext(_ctx, getState()); 12622 enterRule(_localctx, 114, RULE_colTag); 12623 int _la; 12624 try { 12625 enterOuterAlt(_localctx, 1); 12626 { 12627 setState(1423); 12628 match(OPEN); 12629 setState(1424); 12630 match(COL_HTML_TAG_NAME); 12631 setState(1431); 12632 _errHandler.sync(this); 12633 _la = _input.LA(1); 12634 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12635 { 12636 setState(1429); 12637 _errHandler.sync(this); 12638 switch (_input.LA(1)) { 12639 case HTML_TAG_NAME: 12640 { 12641 setState(1425); 12642 attribute(); 12643 } 12644 break; 12645 case NEWLINE: 12646 { 12647 setState(1426); 12648 match(NEWLINE); 12649 } 12650 break; 12651 case LEADING_ASTERISK: 12652 { 12653 setState(1427); 12654 match(LEADING_ASTERISK); 12655 } 12656 break; 12657 case WS: 12658 { 12659 setState(1428); 12660 match(WS); 12661 } 12662 break; 12663 default: 12664 throw new NoViableAltException(this); 12665 } 12666 } 12667 setState(1433); 12668 _errHandler.sync(this); 12669 _la = _input.LA(1); 12670 } 12671 setState(1434); 12672 _la = _input.LA(1); 12673 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12674 _errHandler.recoverInline(this); 12675 } 12676 else { 12677 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12678 _errHandler.reportMatch(this); 12679 consume(); 12680 } 12681 } 12682 } 12683 catch (RecognitionException re) { 12684 _localctx.exception = re; 12685 _errHandler.reportError(this, re); 12686 _errHandler.recover(this, re); 12687 } 12688 finally { 12689 exitRule(); 12690 } 12691 return _localctx; 12692 } 12693 12694 public static class FrameTagContext extends ParserRuleContext { 12695 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12696 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 12697 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12698 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12699 public List<AttributeContext> attribute() { 12700 return getRuleContexts(AttributeContext.class); 12701 } 12702 public AttributeContext attribute(int i) { 12703 return getRuleContext(AttributeContext.class,i); 12704 } 12705 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12706 public TerminalNode NEWLINE(int i) { 12707 return getToken(JavadocParser.NEWLINE, i); 12708 } 12709 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12710 public TerminalNode LEADING_ASTERISK(int i) { 12711 return getToken(JavadocParser.LEADING_ASTERISK, i); 12712 } 12713 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12714 public TerminalNode WS(int i) { 12715 return getToken(JavadocParser.WS, i); 12716 } 12717 public FrameTagContext(ParserRuleContext parent, int invokingState) { 12718 super(parent, invokingState); 12719 } 12720 @Override public int getRuleIndex() { return RULE_frameTag; } 12721 @Override 12722 public void enterRule(ParseTreeListener listener) { 12723 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterFrameTag(this); 12724 } 12725 @Override 12726 public void exitRule(ParseTreeListener listener) { 12727 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitFrameTag(this); 12728 } 12729 @Override 12730 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12731 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitFrameTag(this); 12732 else return visitor.visitChildren(this); 12733 } 12734 } 12735 12736 public final FrameTagContext frameTag() throws RecognitionException { 12737 FrameTagContext _localctx = new FrameTagContext(_ctx, getState()); 12738 enterRule(_localctx, 116, RULE_frameTag); 12739 int _la; 12740 try { 12741 enterOuterAlt(_localctx, 1); 12742 { 12743 setState(1436); 12744 match(OPEN); 12745 setState(1437); 12746 match(FRAME_HTML_TAG_NAME); 12747 setState(1444); 12748 _errHandler.sync(this); 12749 _la = _input.LA(1); 12750 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12751 { 12752 setState(1442); 12753 _errHandler.sync(this); 12754 switch (_input.LA(1)) { 12755 case HTML_TAG_NAME: 12756 { 12757 setState(1438); 12758 attribute(); 12759 } 12760 break; 12761 case NEWLINE: 12762 { 12763 setState(1439); 12764 match(NEWLINE); 12765 } 12766 break; 12767 case LEADING_ASTERISK: 12768 { 12769 setState(1440); 12770 match(LEADING_ASTERISK); 12771 } 12772 break; 12773 case WS: 12774 { 12775 setState(1441); 12776 match(WS); 12777 } 12778 break; 12779 default: 12780 throw new NoViableAltException(this); 12781 } 12782 } 12783 setState(1446); 12784 _errHandler.sync(this); 12785 _la = _input.LA(1); 12786 } 12787 setState(1447); 12788 _la = _input.LA(1); 12789 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12790 _errHandler.recoverInline(this); 12791 } 12792 else { 12793 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12794 _errHandler.reportMatch(this); 12795 consume(); 12796 } 12797 } 12798 } 12799 catch (RecognitionException re) { 12800 _localctx.exception = re; 12801 _errHandler.reportError(this, re); 12802 _errHandler.recover(this, re); 12803 } 12804 finally { 12805 exitRule(); 12806 } 12807 return _localctx; 12808 } 12809 12810 public static class HrTagContext extends ParserRuleContext { 12811 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12812 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 12813 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12814 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12815 public List<AttributeContext> attribute() { 12816 return getRuleContexts(AttributeContext.class); 12817 } 12818 public AttributeContext attribute(int i) { 12819 return getRuleContext(AttributeContext.class,i); 12820 } 12821 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12822 public TerminalNode NEWLINE(int i) { 12823 return getToken(JavadocParser.NEWLINE, i); 12824 } 12825 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12826 public TerminalNode LEADING_ASTERISK(int i) { 12827 return getToken(JavadocParser.LEADING_ASTERISK, i); 12828 } 12829 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12830 public TerminalNode WS(int i) { 12831 return getToken(JavadocParser.WS, i); 12832 } 12833 public HrTagContext(ParserRuleContext parent, int invokingState) { 12834 super(parent, invokingState); 12835 } 12836 @Override public int getRuleIndex() { return RULE_hrTag; } 12837 @Override 12838 public void enterRule(ParseTreeListener listener) { 12839 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHrTag(this); 12840 } 12841 @Override 12842 public void exitRule(ParseTreeListener listener) { 12843 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHrTag(this); 12844 } 12845 @Override 12846 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12847 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHrTag(this); 12848 else return visitor.visitChildren(this); 12849 } 12850 } 12851 12852 public final HrTagContext hrTag() throws RecognitionException { 12853 HrTagContext _localctx = new HrTagContext(_ctx, getState()); 12854 enterRule(_localctx, 118, RULE_hrTag); 12855 int _la; 12856 try { 12857 enterOuterAlt(_localctx, 1); 12858 { 12859 setState(1449); 12860 match(OPEN); 12861 setState(1450); 12862 match(HR_HTML_TAG_NAME); 12863 setState(1457); 12864 _errHandler.sync(this); 12865 _la = _input.LA(1); 12866 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12867 { 12868 setState(1455); 12869 _errHandler.sync(this); 12870 switch (_input.LA(1)) { 12871 case HTML_TAG_NAME: 12872 { 12873 setState(1451); 12874 attribute(); 12875 } 12876 break; 12877 case NEWLINE: 12878 { 12879 setState(1452); 12880 match(NEWLINE); 12881 } 12882 break; 12883 case LEADING_ASTERISK: 12884 { 12885 setState(1453); 12886 match(LEADING_ASTERISK); 12887 } 12888 break; 12889 case WS: 12890 { 12891 setState(1454); 12892 match(WS); 12893 } 12894 break; 12895 default: 12896 throw new NoViableAltException(this); 12897 } 12898 } 12899 setState(1459); 12900 _errHandler.sync(this); 12901 _la = _input.LA(1); 12902 } 12903 setState(1460); 12904 _la = _input.LA(1); 12905 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12906 _errHandler.recoverInline(this); 12907 } 12908 else { 12909 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12910 _errHandler.reportMatch(this); 12911 consume(); 12912 } 12913 } 12914 } 12915 catch (RecognitionException re) { 12916 _localctx.exception = re; 12917 _errHandler.reportError(this, re); 12918 _errHandler.recover(this, re); 12919 } 12920 finally { 12921 exitRule(); 12922 } 12923 return _localctx; 12924 } 12925 12926 public static class ImgTagContext extends ParserRuleContext { 12927 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12928 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 12929 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12930 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12931 public List<AttributeContext> attribute() { 12932 return getRuleContexts(AttributeContext.class); 12933 } 12934 public AttributeContext attribute(int i) { 12935 return getRuleContext(AttributeContext.class,i); 12936 } 12937 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12938 public TerminalNode NEWLINE(int i) { 12939 return getToken(JavadocParser.NEWLINE, i); 12940 } 12941 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12942 public TerminalNode LEADING_ASTERISK(int i) { 12943 return getToken(JavadocParser.LEADING_ASTERISK, i); 12944 } 12945 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12946 public TerminalNode WS(int i) { 12947 return getToken(JavadocParser.WS, i); 12948 } 12949 public ImgTagContext(ParserRuleContext parent, int invokingState) { 12950 super(parent, invokingState); 12951 } 12952 @Override public int getRuleIndex() { return RULE_imgTag; } 12953 @Override 12954 public void enterRule(ParseTreeListener listener) { 12955 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterImgTag(this); 12956 } 12957 @Override 12958 public void exitRule(ParseTreeListener listener) { 12959 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitImgTag(this); 12960 } 12961 @Override 12962 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12963 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitImgTag(this); 12964 else return visitor.visitChildren(this); 12965 } 12966 } 12967 12968 public final ImgTagContext imgTag() throws RecognitionException { 12969 ImgTagContext _localctx = new ImgTagContext(_ctx, getState()); 12970 enterRule(_localctx, 120, RULE_imgTag); 12971 int _la; 12972 try { 12973 enterOuterAlt(_localctx, 1); 12974 { 12975 setState(1462); 12976 match(OPEN); 12977 setState(1463); 12978 match(IMG_HTML_TAG_NAME); 12979 setState(1470); 12980 _errHandler.sync(this); 12981 _la = _input.LA(1); 12982 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12983 { 12984 setState(1468); 12985 _errHandler.sync(this); 12986 switch (_input.LA(1)) { 12987 case HTML_TAG_NAME: 12988 { 12989 setState(1464); 12990 attribute(); 12991 } 12992 break; 12993 case NEWLINE: 12994 { 12995 setState(1465); 12996 match(NEWLINE); 12997 } 12998 break; 12999 case LEADING_ASTERISK: 13000 { 13001 setState(1466); 13002 match(LEADING_ASTERISK); 13003 } 13004 break; 13005 case WS: 13006 { 13007 setState(1467); 13008 match(WS); 13009 } 13010 break; 13011 default: 13012 throw new NoViableAltException(this); 13013 } 13014 } 13015 setState(1472); 13016 _errHandler.sync(this); 13017 _la = _input.LA(1); 13018 } 13019 setState(1473); 13020 _la = _input.LA(1); 13021 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13022 _errHandler.recoverInline(this); 13023 } 13024 else { 13025 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13026 _errHandler.reportMatch(this); 13027 consume(); 13028 } 13029 } 13030 } 13031 catch (RecognitionException re) { 13032 _localctx.exception = re; 13033 _errHandler.reportError(this, re); 13034 _errHandler.recover(this, re); 13035 } 13036 finally { 13037 exitRule(); 13038 } 13039 return _localctx; 13040 } 13041 13042 public static class InputTagContext extends ParserRuleContext { 13043 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13044 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 13045 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13046 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13047 public List<AttributeContext> attribute() { 13048 return getRuleContexts(AttributeContext.class); 13049 } 13050 public AttributeContext attribute(int i) { 13051 return getRuleContext(AttributeContext.class,i); 13052 } 13053 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13054 public TerminalNode NEWLINE(int i) { 13055 return getToken(JavadocParser.NEWLINE, i); 13056 } 13057 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13058 public TerminalNode LEADING_ASTERISK(int i) { 13059 return getToken(JavadocParser.LEADING_ASTERISK, i); 13060 } 13061 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13062 public TerminalNode WS(int i) { 13063 return getToken(JavadocParser.WS, i); 13064 } 13065 public InputTagContext(ParserRuleContext parent, int invokingState) { 13066 super(parent, invokingState); 13067 } 13068 @Override public int getRuleIndex() { return RULE_inputTag; } 13069 @Override 13070 public void enterRule(ParseTreeListener listener) { 13071 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInputTag(this); 13072 } 13073 @Override 13074 public void exitRule(ParseTreeListener listener) { 13075 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInputTag(this); 13076 } 13077 @Override 13078 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13079 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInputTag(this); 13080 else return visitor.visitChildren(this); 13081 } 13082 } 13083 13084 public final InputTagContext inputTag() throws RecognitionException { 13085 InputTagContext _localctx = new InputTagContext(_ctx, getState()); 13086 enterRule(_localctx, 122, RULE_inputTag); 13087 int _la; 13088 try { 13089 enterOuterAlt(_localctx, 1); 13090 { 13091 setState(1475); 13092 match(OPEN); 13093 setState(1476); 13094 match(INPUT_HTML_TAG_NAME); 13095 setState(1483); 13096 _errHandler.sync(this); 13097 _la = _input.LA(1); 13098 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13099 { 13100 setState(1481); 13101 _errHandler.sync(this); 13102 switch (_input.LA(1)) { 13103 case HTML_TAG_NAME: 13104 { 13105 setState(1477); 13106 attribute(); 13107 } 13108 break; 13109 case NEWLINE: 13110 { 13111 setState(1478); 13112 match(NEWLINE); 13113 } 13114 break; 13115 case LEADING_ASTERISK: 13116 { 13117 setState(1479); 13118 match(LEADING_ASTERISK); 13119 } 13120 break; 13121 case WS: 13122 { 13123 setState(1480); 13124 match(WS); 13125 } 13126 break; 13127 default: 13128 throw new NoViableAltException(this); 13129 } 13130 } 13131 setState(1485); 13132 _errHandler.sync(this); 13133 _la = _input.LA(1); 13134 } 13135 setState(1486); 13136 _la = _input.LA(1); 13137 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13138 _errHandler.recoverInline(this); 13139 } 13140 else { 13141 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13142 _errHandler.reportMatch(this); 13143 consume(); 13144 } 13145 } 13146 } 13147 catch (RecognitionException re) { 13148 _localctx.exception = re; 13149 _errHandler.reportError(this, re); 13150 _errHandler.recover(this, re); 13151 } 13152 finally { 13153 exitRule(); 13154 } 13155 return _localctx; 13156 } 13157 13158 public static class IsindexTagContext extends ParserRuleContext { 13159 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13160 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 13161 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13162 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13163 public List<AttributeContext> attribute() { 13164 return getRuleContexts(AttributeContext.class); 13165 } 13166 public AttributeContext attribute(int i) { 13167 return getRuleContext(AttributeContext.class,i); 13168 } 13169 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13170 public TerminalNode NEWLINE(int i) { 13171 return getToken(JavadocParser.NEWLINE, i); 13172 } 13173 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13174 public TerminalNode LEADING_ASTERISK(int i) { 13175 return getToken(JavadocParser.LEADING_ASTERISK, i); 13176 } 13177 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13178 public TerminalNode WS(int i) { 13179 return getToken(JavadocParser.WS, i); 13180 } 13181 public IsindexTagContext(ParserRuleContext parent, int invokingState) { 13182 super(parent, invokingState); 13183 } 13184 @Override public int getRuleIndex() { return RULE_isindexTag; } 13185 @Override 13186 public void enterRule(ParseTreeListener listener) { 13187 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterIsindexTag(this); 13188 } 13189 @Override 13190 public void exitRule(ParseTreeListener listener) { 13191 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitIsindexTag(this); 13192 } 13193 @Override 13194 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13195 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitIsindexTag(this); 13196 else return visitor.visitChildren(this); 13197 } 13198 } 13199 13200 public final IsindexTagContext isindexTag() throws RecognitionException { 13201 IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState()); 13202 enterRule(_localctx, 124, RULE_isindexTag); 13203 int _la; 13204 try { 13205 enterOuterAlt(_localctx, 1); 13206 { 13207 setState(1488); 13208 match(OPEN); 13209 setState(1489); 13210 match(ISINDEX_HTML_TAG_NAME); 13211 setState(1496); 13212 _errHandler.sync(this); 13213 _la = _input.LA(1); 13214 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13215 { 13216 setState(1494); 13217 _errHandler.sync(this); 13218 switch (_input.LA(1)) { 13219 case HTML_TAG_NAME: 13220 { 13221 setState(1490); 13222 attribute(); 13223 } 13224 break; 13225 case NEWLINE: 13226 { 13227 setState(1491); 13228 match(NEWLINE); 13229 } 13230 break; 13231 case LEADING_ASTERISK: 13232 { 13233 setState(1492); 13234 match(LEADING_ASTERISK); 13235 } 13236 break; 13237 case WS: 13238 { 13239 setState(1493); 13240 match(WS); 13241 } 13242 break; 13243 default: 13244 throw new NoViableAltException(this); 13245 } 13246 } 13247 setState(1498); 13248 _errHandler.sync(this); 13249 _la = _input.LA(1); 13250 } 13251 setState(1499); 13252 _la = _input.LA(1); 13253 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13254 _errHandler.recoverInline(this); 13255 } 13256 else { 13257 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13258 _errHandler.reportMatch(this); 13259 consume(); 13260 } 13261 } 13262 } 13263 catch (RecognitionException re) { 13264 _localctx.exception = re; 13265 _errHandler.reportError(this, re); 13266 _errHandler.recover(this, re); 13267 } 13268 finally { 13269 exitRule(); 13270 } 13271 return _localctx; 13272 } 13273 13274 public static class LinkTagContext extends ParserRuleContext { 13275 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13276 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 13277 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13278 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13279 public List<AttributeContext> attribute() { 13280 return getRuleContexts(AttributeContext.class); 13281 } 13282 public AttributeContext attribute(int i) { 13283 return getRuleContext(AttributeContext.class,i); 13284 } 13285 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13286 public TerminalNode NEWLINE(int i) { 13287 return getToken(JavadocParser.NEWLINE, i); 13288 } 13289 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13290 public TerminalNode LEADING_ASTERISK(int i) { 13291 return getToken(JavadocParser.LEADING_ASTERISK, i); 13292 } 13293 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13294 public TerminalNode WS(int i) { 13295 return getToken(JavadocParser.WS, i); 13296 } 13297 public LinkTagContext(ParserRuleContext parent, int invokingState) { 13298 super(parent, invokingState); 13299 } 13300 @Override public int getRuleIndex() { return RULE_linkTag; } 13301 @Override 13302 public void enterRule(ParseTreeListener listener) { 13303 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLinkTag(this); 13304 } 13305 @Override 13306 public void exitRule(ParseTreeListener listener) { 13307 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLinkTag(this); 13308 } 13309 @Override 13310 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13311 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLinkTag(this); 13312 else return visitor.visitChildren(this); 13313 } 13314 } 13315 13316 public final LinkTagContext linkTag() throws RecognitionException { 13317 LinkTagContext _localctx = new LinkTagContext(_ctx, getState()); 13318 enterRule(_localctx, 126, RULE_linkTag); 13319 int _la; 13320 try { 13321 enterOuterAlt(_localctx, 1); 13322 { 13323 setState(1501); 13324 match(OPEN); 13325 setState(1502); 13326 match(LINK_HTML_TAG_NAME); 13327 setState(1509); 13328 _errHandler.sync(this); 13329 _la = _input.LA(1); 13330 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13331 { 13332 setState(1507); 13333 _errHandler.sync(this); 13334 switch (_input.LA(1)) { 13335 case HTML_TAG_NAME: 13336 { 13337 setState(1503); 13338 attribute(); 13339 } 13340 break; 13341 case NEWLINE: 13342 { 13343 setState(1504); 13344 match(NEWLINE); 13345 } 13346 break; 13347 case LEADING_ASTERISK: 13348 { 13349 setState(1505); 13350 match(LEADING_ASTERISK); 13351 } 13352 break; 13353 case WS: 13354 { 13355 setState(1506); 13356 match(WS); 13357 } 13358 break; 13359 default: 13360 throw new NoViableAltException(this); 13361 } 13362 } 13363 setState(1511); 13364 _errHandler.sync(this); 13365 _la = _input.LA(1); 13366 } 13367 setState(1512); 13368 _la = _input.LA(1); 13369 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13370 _errHandler.recoverInline(this); 13371 } 13372 else { 13373 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13374 _errHandler.reportMatch(this); 13375 consume(); 13376 } 13377 } 13378 } 13379 catch (RecognitionException re) { 13380 _localctx.exception = re; 13381 _errHandler.reportError(this, re); 13382 _errHandler.recover(this, re); 13383 } 13384 finally { 13385 exitRule(); 13386 } 13387 return _localctx; 13388 } 13389 13390 public static class MetaTagContext extends ParserRuleContext { 13391 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13392 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 13393 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13394 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13395 public List<AttributeContext> attribute() { 13396 return getRuleContexts(AttributeContext.class); 13397 } 13398 public AttributeContext attribute(int i) { 13399 return getRuleContext(AttributeContext.class,i); 13400 } 13401 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13402 public TerminalNode NEWLINE(int i) { 13403 return getToken(JavadocParser.NEWLINE, i); 13404 } 13405 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13406 public TerminalNode LEADING_ASTERISK(int i) { 13407 return getToken(JavadocParser.LEADING_ASTERISK, i); 13408 } 13409 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13410 public TerminalNode WS(int i) { 13411 return getToken(JavadocParser.WS, i); 13412 } 13413 public MetaTagContext(ParserRuleContext parent, int invokingState) { 13414 super(parent, invokingState); 13415 } 13416 @Override public int getRuleIndex() { return RULE_metaTag; } 13417 @Override 13418 public void enterRule(ParseTreeListener listener) { 13419 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterMetaTag(this); 13420 } 13421 @Override 13422 public void exitRule(ParseTreeListener listener) { 13423 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitMetaTag(this); 13424 } 13425 @Override 13426 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13427 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitMetaTag(this); 13428 else return visitor.visitChildren(this); 13429 } 13430 } 13431 13432 public final MetaTagContext metaTag() throws RecognitionException { 13433 MetaTagContext _localctx = new MetaTagContext(_ctx, getState()); 13434 enterRule(_localctx, 128, RULE_metaTag); 13435 int _la; 13436 try { 13437 enterOuterAlt(_localctx, 1); 13438 { 13439 setState(1514); 13440 match(OPEN); 13441 setState(1515); 13442 match(META_HTML_TAG_NAME); 13443 setState(1522); 13444 _errHandler.sync(this); 13445 _la = _input.LA(1); 13446 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13447 { 13448 setState(1520); 13449 _errHandler.sync(this); 13450 switch (_input.LA(1)) { 13451 case HTML_TAG_NAME: 13452 { 13453 setState(1516); 13454 attribute(); 13455 } 13456 break; 13457 case NEWLINE: 13458 { 13459 setState(1517); 13460 match(NEWLINE); 13461 } 13462 break; 13463 case LEADING_ASTERISK: 13464 { 13465 setState(1518); 13466 match(LEADING_ASTERISK); 13467 } 13468 break; 13469 case WS: 13470 { 13471 setState(1519); 13472 match(WS); 13473 } 13474 break; 13475 default: 13476 throw new NoViableAltException(this); 13477 } 13478 } 13479 setState(1524); 13480 _errHandler.sync(this); 13481 _la = _input.LA(1); 13482 } 13483 setState(1525); 13484 _la = _input.LA(1); 13485 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13486 _errHandler.recoverInline(this); 13487 } 13488 else { 13489 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13490 _errHandler.reportMatch(this); 13491 consume(); 13492 } 13493 } 13494 } 13495 catch (RecognitionException re) { 13496 _localctx.exception = re; 13497 _errHandler.reportError(this, re); 13498 _errHandler.recover(this, re); 13499 } 13500 finally { 13501 exitRule(); 13502 } 13503 return _localctx; 13504 } 13505 13506 public static class ParamTagContext extends ParserRuleContext { 13507 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13508 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 13509 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13510 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13511 public List<AttributeContext> attribute() { 13512 return getRuleContexts(AttributeContext.class); 13513 } 13514 public AttributeContext attribute(int i) { 13515 return getRuleContext(AttributeContext.class,i); 13516 } 13517 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13518 public TerminalNode NEWLINE(int i) { 13519 return getToken(JavadocParser.NEWLINE, i); 13520 } 13521 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13522 public TerminalNode LEADING_ASTERISK(int i) { 13523 return getToken(JavadocParser.LEADING_ASTERISK, i); 13524 } 13525 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13526 public TerminalNode WS(int i) { 13527 return getToken(JavadocParser.WS, i); 13528 } 13529 public ParamTagContext(ParserRuleContext parent, int invokingState) { 13530 super(parent, invokingState); 13531 } 13532 @Override public int getRuleIndex() { return RULE_paramTag; } 13533 @Override 13534 public void enterRule(ParseTreeListener listener) { 13535 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParamTag(this); 13536 } 13537 @Override 13538 public void exitRule(ParseTreeListener listener) { 13539 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParamTag(this); 13540 } 13541 @Override 13542 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13543 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParamTag(this); 13544 else return visitor.visitChildren(this); 13545 } 13546 } 13547 13548 public final ParamTagContext paramTag() throws RecognitionException { 13549 ParamTagContext _localctx = new ParamTagContext(_ctx, getState()); 13550 enterRule(_localctx, 130, RULE_paramTag); 13551 int _la; 13552 try { 13553 enterOuterAlt(_localctx, 1); 13554 { 13555 setState(1527); 13556 match(OPEN); 13557 setState(1528); 13558 match(PARAM_HTML_TAG_NAME); 13559 setState(1535); 13560 _errHandler.sync(this); 13561 _la = _input.LA(1); 13562 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13563 { 13564 setState(1533); 13565 _errHandler.sync(this); 13566 switch (_input.LA(1)) { 13567 case HTML_TAG_NAME: 13568 { 13569 setState(1529); 13570 attribute(); 13571 } 13572 break; 13573 case NEWLINE: 13574 { 13575 setState(1530); 13576 match(NEWLINE); 13577 } 13578 break; 13579 case LEADING_ASTERISK: 13580 { 13581 setState(1531); 13582 match(LEADING_ASTERISK); 13583 } 13584 break; 13585 case WS: 13586 { 13587 setState(1532); 13588 match(WS); 13589 } 13590 break; 13591 default: 13592 throw new NoViableAltException(this); 13593 } 13594 } 13595 setState(1537); 13596 _errHandler.sync(this); 13597 _la = _input.LA(1); 13598 } 13599 setState(1538); 13600 _la = _input.LA(1); 13601 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13602 _errHandler.recoverInline(this); 13603 } 13604 else { 13605 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13606 _errHandler.reportMatch(this); 13607 consume(); 13608 } 13609 } 13610 } 13611 catch (RecognitionException re) { 13612 _localctx.exception = re; 13613 _errHandler.reportError(this, re); 13614 _errHandler.recover(this, re); 13615 } 13616 finally { 13617 exitRule(); 13618 } 13619 return _localctx; 13620 } 13621 13622 public static class WrongSinletonTagContext extends ParserRuleContext { 13623 public SingletonTagNameContext singletonTagName; 13624 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13625 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 13626 public SingletonTagNameContext singletonTagName() { 13627 return getRuleContext(SingletonTagNameContext.class,0); 13628 } 13629 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13630 public WrongSinletonTagContext(ParserRuleContext parent, int invokingState) { 13631 super(parent, invokingState); 13632 } 13633 @Override public int getRuleIndex() { return RULE_wrongSinletonTag; } 13634 @Override 13635 public void enterRule(ParseTreeListener listener) { 13636 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterWrongSinletonTag(this); 13637 } 13638 @Override 13639 public void exitRule(ParseTreeListener listener) { 13640 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitWrongSinletonTag(this); 13641 } 13642 @Override 13643 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13644 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWrongSinletonTag(this); 13645 else return visitor.visitChildren(this); 13646 } 13647 } 13648 13649 public final WrongSinletonTagContext wrongSinletonTag() throws RecognitionException { 13650 WrongSinletonTagContext _localctx = new WrongSinletonTagContext(_ctx, getState()); 13651 enterRule(_localctx, 132, RULE_wrongSinletonTag); 13652 try { 13653 enterOuterAlt(_localctx, 1); 13654 { 13655 setState(1540); 13656 match(OPEN); 13657 setState(1541); 13658 match(SLASH); 13659 setState(1542); 13660 ((WrongSinletonTagContext)_localctx).singletonTagName = singletonTagName(); 13661 setState(1543); 13662 match(CLOSE); 13663 notifyErrorListeners((((WrongSinletonTagContext)_localctx).singletonTagName!=null?(((WrongSinletonTagContext)_localctx).singletonTagName.start):null), 13664 "javadoc.wrong.singleton.html.tag", null); 13665 } 13666 } 13667 catch (RecognitionException re) { 13668 _localctx.exception = re; 13669 _errHandler.reportError(this, re); 13670 _errHandler.recover(this, re); 13671 } 13672 finally { 13673 exitRule(); 13674 } 13675 return _localctx; 13676 } 13677 13678 public static class SingletonTagNameContext extends ParserRuleContext { 13679 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 13680 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 13681 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 13682 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 13683 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 13684 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 13685 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 13686 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 13687 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 13688 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 13689 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 13690 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 13691 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 13692 public SingletonTagNameContext(ParserRuleContext parent, int invokingState) { 13693 super(parent, invokingState); 13694 } 13695 @Override public int getRuleIndex() { return RULE_singletonTagName; } 13696 @Override 13697 public void enterRule(ParseTreeListener listener) { 13698 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTagName(this); 13699 } 13700 @Override 13701 public void exitRule(ParseTreeListener listener) { 13702 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTagName(this); 13703 } 13704 @Override 13705 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13706 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTagName(this); 13707 else return visitor.visitChildren(this); 13708 } 13709 } 13710 13711 public final SingletonTagNameContext singletonTagName() throws RecognitionException { 13712 SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState()); 13713 enterRule(_localctx, 134, RULE_singletonTagName); 13714 int _la; 13715 try { 13716 enterOuterAlt(_localctx, 1); 13717 { 13718 setState(1546); 13719 _la = _input.LA(1); 13720 if ( !(((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (AREA_HTML_TAG_NAME - 74)) | (1L << (BASE_HTML_TAG_NAME - 74)) | (1L << (BASEFONT_HTML_TAG_NAME - 74)) | (1L << (BR_HTML_TAG_NAME - 74)) | (1L << (COL_HTML_TAG_NAME - 74)) | (1L << (FRAME_HTML_TAG_NAME - 74)) | (1L << (HR_HTML_TAG_NAME - 74)) | (1L << (IMG_HTML_TAG_NAME - 74)) | (1L << (INPUT_HTML_TAG_NAME - 74)) | (1L << (ISINDEX_HTML_TAG_NAME - 74)) | (1L << (LINK_HTML_TAG_NAME - 74)) | (1L << (META_HTML_TAG_NAME - 74)) | (1L << (PARAM_HTML_TAG_NAME - 74)))) != 0)) ) { 13721 _errHandler.recoverInline(this); 13722 } 13723 else { 13724 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13725 _errHandler.reportMatch(this); 13726 consume(); 13727 } 13728 } 13729 } 13730 catch (RecognitionException re) { 13731 _localctx.exception = re; 13732 _errHandler.reportError(this, re); 13733 _errHandler.recover(this, re); 13734 } 13735 finally { 13736 exitRule(); 13737 } 13738 return _localctx; 13739 } 13740 13741 public static class DescriptionContext extends ParserRuleContext { 13742 public List<HtmlCommentContext> htmlComment() { 13743 return getRuleContexts(HtmlCommentContext.class); 13744 } 13745 public HtmlCommentContext htmlComment(int i) { 13746 return getRuleContext(HtmlCommentContext.class,i); 13747 } 13748 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 13749 public TerminalNode CDATA(int i) { 13750 return getToken(JavadocParser.CDATA, i); 13751 } 13752 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13753 public TerminalNode NEWLINE(int i) { 13754 return getToken(JavadocParser.NEWLINE, i); 13755 } 13756 public List<TextContext> text() { 13757 return getRuleContexts(TextContext.class); 13758 } 13759 public TextContext text(int i) { 13760 return getRuleContext(TextContext.class,i); 13761 } 13762 public List<JavadocInlineTagContext> javadocInlineTag() { 13763 return getRuleContexts(JavadocInlineTagContext.class); 13764 } 13765 public JavadocInlineTagContext javadocInlineTag(int i) { 13766 return getRuleContext(JavadocInlineTagContext.class,i); 13767 } 13768 public List<HtmlElementContext> htmlElement() { 13769 return getRuleContexts(HtmlElementContext.class); 13770 } 13771 public HtmlElementContext htmlElement(int i) { 13772 return getRuleContext(HtmlElementContext.class,i); 13773 } 13774 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13775 public TerminalNode LEADING_ASTERISK(int i) { 13776 return getToken(JavadocParser.LEADING_ASTERISK, i); 13777 } 13778 public DescriptionContext(ParserRuleContext parent, int invokingState) { 13779 super(parent, invokingState); 13780 } 13781 @Override public int getRuleIndex() { return RULE_description; } 13782 @Override 13783 public void enterRule(ParseTreeListener listener) { 13784 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescription(this); 13785 } 13786 @Override 13787 public void exitRule(ParseTreeListener listener) { 13788 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescription(this); 13789 } 13790 @Override 13791 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13792 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this); 13793 else return visitor.visitChildren(this); 13794 } 13795 } 13796 13797 public final DescriptionContext description() throws RecognitionException { 13798 DescriptionContext _localctx = new DescriptionContext(_ctx, getState()); 13799 enterRule(_localctx, 136, RULE_description); 13800 try { 13801 int _alt; 13802 enterOuterAlt(_localctx, 1); 13803 { 13804 setState(1556); 13805 _errHandler.sync(this); 13806 _alt = 1; 13807 do { 13808 switch (_alt) { 13809 case 1: 13810 { 13811 setState(1556); 13812 _errHandler.sync(this); 13813 switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) { 13814 case 1: 13815 { 13816 { 13817 setState(1548); 13818 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 13819 setState(1549); 13820 match(LEADING_ASTERISK); 13821 } 13822 } 13823 break; 13824 case 2: 13825 { 13826 setState(1550); 13827 htmlComment(); 13828 } 13829 break; 13830 case 3: 13831 { 13832 setState(1551); 13833 match(CDATA); 13834 } 13835 break; 13836 case 4: 13837 { 13838 setState(1552); 13839 match(NEWLINE); 13840 } 13841 break; 13842 case 5: 13843 { 13844 setState(1553); 13845 text(); 13846 } 13847 break; 13848 case 6: 13849 { 13850 setState(1554); 13851 javadocInlineTag(); 13852 } 13853 break; 13854 case 7: 13855 { 13856 setState(1555); 13857 htmlElement(); 13858 } 13859 break; 13860 } 13861 } 13862 break; 13863 default: 13864 throw new NoViableAltException(this); 13865 } 13866 setState(1558); 13867 _errHandler.sync(this); 13868 _alt = getInterpreter().adaptivePredict(_input,122,_ctx); 13869 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13870 } 13871 } 13872 catch (RecognitionException re) { 13873 _localctx.exception = re; 13874 _errHandler.reportError(this, re); 13875 _errHandler.recover(this, re); 13876 } 13877 finally { 13878 exitRule(); 13879 } 13880 return _localctx; 13881 } 13882 13883 public static class ReferenceContext extends ParserRuleContext { 13884 public TerminalNode PACKAGE() { return getToken(JavadocParser.PACKAGE, 0); } 13885 public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); } 13886 public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); } 13887 public ParametersContext parameters() { 13888 return getRuleContext(ParametersContext.class,0); 13889 } 13890 public List<TerminalNode> DOT() { return getTokens(JavadocParser.DOT); } 13891 public TerminalNode DOT(int i) { 13892 return getToken(JavadocParser.DOT, i); 13893 } 13894 public List<TerminalNode> CLASS() { return getTokens(JavadocParser.CLASS); } 13895 public TerminalNode CLASS(int i) { 13896 return getToken(JavadocParser.CLASS, i); 13897 } 13898 public ReferenceContext(ParserRuleContext parent, int invokingState) { 13899 super(parent, invokingState); 13900 } 13901 @Override public int getRuleIndex() { return RULE_reference; } 13902 @Override 13903 public void enterRule(ParseTreeListener listener) { 13904 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterReference(this); 13905 } 13906 @Override 13907 public void exitRule(ParseTreeListener listener) { 13908 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitReference(this); 13909 } 13910 @Override 13911 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13912 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitReference(this); 13913 else return visitor.visitChildren(this); 13914 } 13915 } 13916 13917 public final ReferenceContext reference() throws RecognitionException { 13918 ReferenceContext _localctx = new ReferenceContext(_ctx, getState()); 13919 enterRule(_localctx, 138, RULE_reference); 13920 int _la; 13921 try { 13922 int _alt; 13923 enterOuterAlt(_localctx, 1); 13924 { 13925 setState(1597); 13926 _errHandler.sync(this); 13927 switch (_input.LA(1)) { 13928 case PACKAGE: 13929 { 13930 setState(1560); 13931 match(PACKAGE); 13932 setState(1564); 13933 _errHandler.sync(this); 13934 _alt = getInterpreter().adaptivePredict(_input,123,_ctx); 13935 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13936 if ( _alt==1 ) { 13937 { 13938 { 13939 setState(1561); 13940 _la = _input.LA(1); 13941 if ( !(_la==DOT || _la==CLASS) ) { 13942 _errHandler.recoverInline(this); 13943 } 13944 else { 13945 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13946 _errHandler.reportMatch(this); 13947 consume(); 13948 } 13949 } 13950 } 13951 } 13952 setState(1566); 13953 _errHandler.sync(this); 13954 _alt = getInterpreter().adaptivePredict(_input,123,_ctx); 13955 } 13956 setState(1568); 13957 _errHandler.sync(this); 13958 switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) { 13959 case 1: 13960 { 13961 setState(1567); 13962 match(HASH); 13963 } 13964 break; 13965 } 13966 setState(1571); 13967 _errHandler.sync(this); 13968 switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) { 13969 case 1: 13970 { 13971 setState(1570); 13972 match(MEMBER); 13973 } 13974 break; 13975 } 13976 setState(1574); 13977 _errHandler.sync(this); 13978 switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) { 13979 case 1: 13980 { 13981 setState(1573); 13982 parameters(); 13983 } 13984 break; 13985 } 13986 } 13987 break; 13988 case DOT: 13989 case CLASS: 13990 { 13991 setState(1577); 13992 _errHandler.sync(this); 13993 _alt = 1; 13994 do { 13995 switch (_alt) { 13996 case 1: 13997 { 13998 { 13999 setState(1576); 14000 _la = _input.LA(1); 14001 if ( !(_la==DOT || _la==CLASS) ) { 14002 _errHandler.recoverInline(this); 14003 } 14004 else { 14005 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14006 _errHandler.reportMatch(this); 14007 consume(); 14008 } 14009 } 14010 } 14011 break; 14012 default: 14013 throw new NoViableAltException(this); 14014 } 14015 setState(1579); 14016 _errHandler.sync(this); 14017 _alt = getInterpreter().adaptivePredict(_input,127,_ctx); 14018 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 14019 setState(1582); 14020 _errHandler.sync(this); 14021 switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { 14022 case 1: 14023 { 14024 setState(1581); 14025 match(HASH); 14026 } 14027 break; 14028 } 14029 setState(1585); 14030 _errHandler.sync(this); 14031 switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) { 14032 case 1: 14033 { 14034 setState(1584); 14035 match(MEMBER); 14036 } 14037 break; 14038 } 14039 setState(1588); 14040 _errHandler.sync(this); 14041 switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) { 14042 case 1: 14043 { 14044 setState(1587); 14045 parameters(); 14046 } 14047 break; 14048 } 14049 } 14050 break; 14051 case HASH: 14052 case MEMBER: 14053 { 14054 setState(1591); 14055 _errHandler.sync(this); 14056 _la = _input.LA(1); 14057 if (_la==HASH) { 14058 { 14059 setState(1590); 14060 match(HASH); 14061 } 14062 } 14063 14064 setState(1593); 14065 match(MEMBER); 14066 setState(1595); 14067 _errHandler.sync(this); 14068 switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { 14069 case 1: 14070 { 14071 setState(1594); 14072 parameters(); 14073 } 14074 break; 14075 } 14076 } 14077 break; 14078 default: 14079 throw new NoViableAltException(this); 14080 } 14081 } 14082 } 14083 catch (RecognitionException re) { 14084 _localctx.exception = re; 14085 _errHandler.reportError(this, re); 14086 _errHandler.recover(this, re); 14087 } 14088 finally { 14089 exitRule(); 14090 } 14091 return _localctx; 14092 } 14093 14094 public static class ParametersContext extends ParserRuleContext { 14095 public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); } 14096 public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); } 14097 public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); } 14098 public TerminalNode ARGUMENT(int i) { 14099 return getToken(JavadocParser.ARGUMENT, i); 14100 } 14101 public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); } 14102 public TerminalNode COMMA(int i) { 14103 return getToken(JavadocParser.COMMA, i); 14104 } 14105 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14106 public TerminalNode WS(int i) { 14107 return getToken(JavadocParser.WS, i); 14108 } 14109 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14110 public TerminalNode NEWLINE(int i) { 14111 return getToken(JavadocParser.NEWLINE, i); 14112 } 14113 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14114 public TerminalNode LEADING_ASTERISK(int i) { 14115 return getToken(JavadocParser.LEADING_ASTERISK, i); 14116 } 14117 public ParametersContext(ParserRuleContext parent, int invokingState) { 14118 super(parent, invokingState); 14119 } 14120 @Override public int getRuleIndex() { return RULE_parameters; } 14121 @Override 14122 public void enterRule(ParseTreeListener listener) { 14123 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParameters(this); 14124 } 14125 @Override 14126 public void exitRule(ParseTreeListener listener) { 14127 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParameters(this); 14128 } 14129 @Override 14130 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14131 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParameters(this); 14132 else return visitor.visitChildren(this); 14133 } 14134 } 14135 14136 public final ParametersContext parameters() throws RecognitionException { 14137 ParametersContext _localctx = new ParametersContext(_ctx, getState()); 14138 enterRule(_localctx, 140, RULE_parameters); 14139 int _la; 14140 try { 14141 enterOuterAlt(_localctx, 1); 14142 { 14143 setState(1599); 14144 match(LEFT_BRACE); 14145 setState(1603); 14146 _errHandler.sync(this); 14147 _la = _input.LA(1); 14148 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) { 14149 { 14150 { 14151 setState(1600); 14152 _la = _input.LA(1); 14153 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) { 14154 _errHandler.recoverInline(this); 14155 } 14156 else { 14157 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14158 _errHandler.reportMatch(this); 14159 consume(); 14160 } 14161 } 14162 } 14163 setState(1605); 14164 _errHandler.sync(this); 14165 _la = _input.LA(1); 14166 } 14167 setState(1606); 14168 match(RIGHT_BRACE); 14169 } 14170 } 14171 catch (RecognitionException re) { 14172 _localctx.exception = re; 14173 _errHandler.reportError(this, re); 14174 _errHandler.recover(this, re); 14175 } 14176 finally { 14177 exitRule(); 14178 } 14179 return _localctx; 14180 } 14181 14182 public static class JavadocTagContext extends ParserRuleContext { 14183 public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); } 14184 public DescriptionContext description() { 14185 return getRuleContext(DescriptionContext.class,0); 14186 } 14187 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14188 public TerminalNode WS(int i) { 14189 return getToken(JavadocParser.WS, i); 14190 } 14191 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14192 public TerminalNode NEWLINE(int i) { 14193 return getToken(JavadocParser.NEWLINE, i); 14194 } 14195 public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); } 14196 public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); } 14197 public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); } 14198 public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); } 14199 public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); } 14200 public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); } 14201 public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); } 14202 public ReferenceContext reference() { 14203 return getRuleContext(ReferenceContext.class,0); 14204 } 14205 public List<TerminalNode> STRING() { return getTokens(JavadocParser.STRING); } 14206 public TerminalNode STRING(int i) { 14207 return getToken(JavadocParser.STRING, i); 14208 } 14209 public List<HtmlElementContext> htmlElement() { 14210 return getRuleContexts(HtmlElementContext.class); 14211 } 14212 public HtmlElementContext htmlElement(int i) { 14213 return getRuleContext(HtmlElementContext.class,i); 14214 } 14215 public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); } 14216 public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); } 14217 public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); } 14218 public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); } 14219 public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); } 14220 public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); } 14221 public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); } 14222 public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); } 14223 public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); } 14224 public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); } 14225 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 14226 public JavadocTagContext(ParserRuleContext parent, int invokingState) { 14227 super(parent, invokingState); 14228 } 14229 @Override public int getRuleIndex() { return RULE_javadocTag; } 14230 @Override 14231 public void enterRule(ParseTreeListener listener) { 14232 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocTag(this); 14233 } 14234 @Override 14235 public void exitRule(ParseTreeListener listener) { 14236 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocTag(this); 14237 } 14238 @Override 14239 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14240 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocTag(this); 14241 else return visitor.visitChildren(this); 14242 } 14243 } 14244 14245 public final JavadocTagContext javadocTag() throws RecognitionException { 14246 JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState()); 14247 enterRule(_localctx, 142, RULE_javadocTag); 14248 int _la; 14249 try { 14250 int _alt; 14251 setState(1802); 14252 _errHandler.sync(this); 14253 switch (_input.LA(1)) { 14254 case AUTHOR_LITERAL: 14255 enterOuterAlt(_localctx, 1); 14256 { 14257 setState(1608); 14258 match(AUTHOR_LITERAL); 14259 setState(1612); 14260 _errHandler.sync(this); 14261 _alt = getInterpreter().adaptivePredict(_input,135,_ctx); 14262 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14263 if ( _alt==1 ) { 14264 { 14265 { 14266 setState(1609); 14267 _la = _input.LA(1); 14268 if ( !(_la==WS || _la==NEWLINE) ) { 14269 _errHandler.recoverInline(this); 14270 } 14271 else { 14272 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14273 _errHandler.reportMatch(this); 14274 consume(); 14275 } 14276 } 14277 } 14278 } 14279 setState(1614); 14280 _errHandler.sync(this); 14281 _alt = getInterpreter().adaptivePredict(_input,135,_ctx); 14282 } 14283 setState(1616); 14284 _errHandler.sync(this); 14285 switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) { 14286 case 1: 14287 { 14288 setState(1615); 14289 description(); 14290 } 14291 break; 14292 } 14293 } 14294 break; 14295 case DEPRECATED_LITERAL: 14296 enterOuterAlt(_localctx, 2); 14297 { 14298 setState(1618); 14299 match(DEPRECATED_LITERAL); 14300 setState(1622); 14301 _errHandler.sync(this); 14302 _alt = getInterpreter().adaptivePredict(_input,137,_ctx); 14303 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14304 if ( _alt==1 ) { 14305 { 14306 { 14307 setState(1619); 14308 _la = _input.LA(1); 14309 if ( !(_la==WS || _la==NEWLINE) ) { 14310 _errHandler.recoverInline(this); 14311 } 14312 else { 14313 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14314 _errHandler.reportMatch(this); 14315 consume(); 14316 } 14317 } 14318 } 14319 } 14320 setState(1624); 14321 _errHandler.sync(this); 14322 _alt = getInterpreter().adaptivePredict(_input,137,_ctx); 14323 } 14324 setState(1626); 14325 _errHandler.sync(this); 14326 switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { 14327 case 1: 14328 { 14329 setState(1625); 14330 description(); 14331 } 14332 break; 14333 } 14334 } 14335 break; 14336 case EXCEPTION_LITERAL: 14337 enterOuterAlt(_localctx, 3); 14338 { 14339 setState(1628); 14340 match(EXCEPTION_LITERAL); 14341 setState(1632); 14342 _errHandler.sync(this); 14343 _alt = getInterpreter().adaptivePredict(_input,139,_ctx); 14344 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14345 if ( _alt==1 ) { 14346 { 14347 { 14348 setState(1629); 14349 _la = _input.LA(1); 14350 if ( !(_la==WS || _la==NEWLINE) ) { 14351 _errHandler.recoverInline(this); 14352 } 14353 else { 14354 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14355 _errHandler.reportMatch(this); 14356 consume(); 14357 } 14358 } 14359 } 14360 } 14361 setState(1634); 14362 _errHandler.sync(this); 14363 _alt = getInterpreter().adaptivePredict(_input,139,_ctx); 14364 } 14365 setState(1636); 14366 _errHandler.sync(this); 14367 switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) { 14368 case 1: 14369 { 14370 setState(1635); 14371 match(CLASS_NAME); 14372 } 14373 break; 14374 } 14375 setState(1641); 14376 _errHandler.sync(this); 14377 _alt = getInterpreter().adaptivePredict(_input,141,_ctx); 14378 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14379 if ( _alt==1 ) { 14380 { 14381 { 14382 setState(1638); 14383 _la = _input.LA(1); 14384 if ( !(_la==WS || _la==NEWLINE) ) { 14385 _errHandler.recoverInline(this); 14386 } 14387 else { 14388 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14389 _errHandler.reportMatch(this); 14390 consume(); 14391 } 14392 } 14393 } 14394 } 14395 setState(1643); 14396 _errHandler.sync(this); 14397 _alt = getInterpreter().adaptivePredict(_input,141,_ctx); 14398 } 14399 setState(1645); 14400 _errHandler.sync(this); 14401 switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) { 14402 case 1: 14403 { 14404 setState(1644); 14405 description(); 14406 } 14407 break; 14408 } 14409 } 14410 break; 14411 case PARAM_LITERAL: 14412 enterOuterAlt(_localctx, 4); 14413 { 14414 setState(1647); 14415 match(PARAM_LITERAL); 14416 setState(1651); 14417 _errHandler.sync(this); 14418 _alt = getInterpreter().adaptivePredict(_input,143,_ctx); 14419 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14420 if ( _alt==1 ) { 14421 { 14422 { 14423 setState(1648); 14424 _la = _input.LA(1); 14425 if ( !(_la==WS || _la==NEWLINE) ) { 14426 _errHandler.recoverInline(this); 14427 } 14428 else { 14429 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14430 _errHandler.reportMatch(this); 14431 consume(); 14432 } 14433 } 14434 } 14435 } 14436 setState(1653); 14437 _errHandler.sync(this); 14438 _alt = getInterpreter().adaptivePredict(_input,143,_ctx); 14439 } 14440 setState(1655); 14441 _errHandler.sync(this); 14442 switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { 14443 case 1: 14444 { 14445 setState(1654); 14446 match(PARAMETER_NAME); 14447 } 14448 break; 14449 } 14450 setState(1660); 14451 _errHandler.sync(this); 14452 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 14453 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14454 if ( _alt==1 ) { 14455 { 14456 { 14457 setState(1657); 14458 _la = _input.LA(1); 14459 if ( !(_la==WS || _la==NEWLINE) ) { 14460 _errHandler.recoverInline(this); 14461 } 14462 else { 14463 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14464 _errHandler.reportMatch(this); 14465 consume(); 14466 } 14467 } 14468 } 14469 } 14470 setState(1662); 14471 _errHandler.sync(this); 14472 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 14473 } 14474 setState(1664); 14475 _errHandler.sync(this); 14476 switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { 14477 case 1: 14478 { 14479 setState(1663); 14480 description(); 14481 } 14482 break; 14483 } 14484 } 14485 break; 14486 case RETURN_LITERAL: 14487 enterOuterAlt(_localctx, 5); 14488 { 14489 setState(1666); 14490 match(RETURN_LITERAL); 14491 setState(1670); 14492 _errHandler.sync(this); 14493 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 14494 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14495 if ( _alt==1 ) { 14496 { 14497 { 14498 setState(1667); 14499 _la = _input.LA(1); 14500 if ( !(_la==WS || _la==NEWLINE) ) { 14501 _errHandler.recoverInline(this); 14502 } 14503 else { 14504 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14505 _errHandler.reportMatch(this); 14506 consume(); 14507 } 14508 } 14509 } 14510 } 14511 setState(1672); 14512 _errHandler.sync(this); 14513 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 14514 } 14515 setState(1674); 14516 _errHandler.sync(this); 14517 switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { 14518 case 1: 14519 { 14520 setState(1673); 14521 description(); 14522 } 14523 break; 14524 } 14525 } 14526 break; 14527 case SEE_LITERAL: 14528 enterOuterAlt(_localctx, 6); 14529 { 14530 setState(1676); 14531 match(SEE_LITERAL); 14532 setState(1680); 14533 _errHandler.sync(this); 14534 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 14535 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14536 if ( _alt==1 ) { 14537 { 14538 { 14539 setState(1677); 14540 _la = _input.LA(1); 14541 if ( !(_la==WS || _la==NEWLINE) ) { 14542 _errHandler.recoverInline(this); 14543 } 14544 else { 14545 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14546 _errHandler.reportMatch(this); 14547 consume(); 14548 } 14549 } 14550 } 14551 } 14552 setState(1682); 14553 _errHandler.sync(this); 14554 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 14555 } 14556 setState(1684); 14557 _errHandler.sync(this); 14558 switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { 14559 case 1: 14560 { 14561 setState(1683); 14562 reference(); 14563 } 14564 break; 14565 } 14566 setState(1690); 14567 _errHandler.sync(this); 14568 _alt = getInterpreter().adaptivePredict(_input,152,_ctx); 14569 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14570 if ( _alt==1 ) { 14571 { 14572 setState(1688); 14573 _errHandler.sync(this); 14574 switch (_input.LA(1)) { 14575 case STRING: 14576 { 14577 setState(1686); 14578 match(STRING); 14579 } 14580 break; 14581 case OPEN: 14582 { 14583 setState(1687); 14584 htmlElement(); 14585 } 14586 break; 14587 default: 14588 throw new NoViableAltException(this); 14589 } 14590 } 14591 } 14592 setState(1692); 14593 _errHandler.sync(this); 14594 _alt = getInterpreter().adaptivePredict(_input,152,_ctx); 14595 } 14596 setState(1696); 14597 _errHandler.sync(this); 14598 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 14599 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14600 if ( _alt==1 ) { 14601 { 14602 { 14603 setState(1693); 14604 _la = _input.LA(1); 14605 if ( !(_la==WS || _la==NEWLINE) ) { 14606 _errHandler.recoverInline(this); 14607 } 14608 else { 14609 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14610 _errHandler.reportMatch(this); 14611 consume(); 14612 } 14613 } 14614 } 14615 } 14616 setState(1698); 14617 _errHandler.sync(this); 14618 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 14619 } 14620 setState(1700); 14621 _errHandler.sync(this); 14622 switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { 14623 case 1: 14624 { 14625 setState(1699); 14626 description(); 14627 } 14628 break; 14629 } 14630 } 14631 break; 14632 case SERIAL_LITERAL: 14633 enterOuterAlt(_localctx, 7); 14634 { 14635 setState(1702); 14636 match(SERIAL_LITERAL); 14637 setState(1706); 14638 _errHandler.sync(this); 14639 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 14640 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14641 if ( _alt==1 ) { 14642 { 14643 { 14644 setState(1703); 14645 _la = _input.LA(1); 14646 if ( !(_la==WS || _la==NEWLINE) ) { 14647 _errHandler.recoverInline(this); 14648 } 14649 else { 14650 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14651 _errHandler.reportMatch(this); 14652 consume(); 14653 } 14654 } 14655 } 14656 } 14657 setState(1708); 14658 _errHandler.sync(this); 14659 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 14660 } 14661 setState(1710); 14662 _errHandler.sync(this); 14663 switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { 14664 case 1: 14665 { 14666 setState(1709); 14667 _la = _input.LA(1); 14668 if ( !(_la==LITERAL_INCLUDE || _la==LITERAL_EXCLUDE) ) { 14669 _errHandler.recoverInline(this); 14670 } 14671 else { 14672 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14673 _errHandler.reportMatch(this); 14674 consume(); 14675 } 14676 } 14677 break; 14678 } 14679 setState(1713); 14680 _errHandler.sync(this); 14681 switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { 14682 case 1: 14683 { 14684 setState(1712); 14685 description(); 14686 } 14687 break; 14688 } 14689 } 14690 break; 14691 case SERIAL_DATA_LITERAL: 14692 enterOuterAlt(_localctx, 8); 14693 { 14694 setState(1715); 14695 match(SERIAL_DATA_LITERAL); 14696 setState(1719); 14697 _errHandler.sync(this); 14698 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14699 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14700 if ( _alt==1 ) { 14701 { 14702 { 14703 setState(1716); 14704 _la = _input.LA(1); 14705 if ( !(_la==WS || _la==NEWLINE) ) { 14706 _errHandler.recoverInline(this); 14707 } 14708 else { 14709 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14710 _errHandler.reportMatch(this); 14711 consume(); 14712 } 14713 } 14714 } 14715 } 14716 setState(1721); 14717 _errHandler.sync(this); 14718 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14719 } 14720 setState(1723); 14721 _errHandler.sync(this); 14722 switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) { 14723 case 1: 14724 { 14725 setState(1722); 14726 description(); 14727 } 14728 break; 14729 } 14730 } 14731 break; 14732 case SERIAL_FIELD_LITERAL: 14733 enterOuterAlt(_localctx, 9); 14734 { 14735 setState(1725); 14736 match(SERIAL_FIELD_LITERAL); 14737 setState(1729); 14738 _errHandler.sync(this); 14739 _alt = getInterpreter().adaptivePredict(_input,160,_ctx); 14740 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14741 if ( _alt==1 ) { 14742 { 14743 { 14744 setState(1726); 14745 _la = _input.LA(1); 14746 if ( !(_la==WS || _la==NEWLINE) ) { 14747 _errHandler.recoverInline(this); 14748 } 14749 else { 14750 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14751 _errHandler.reportMatch(this); 14752 consume(); 14753 } 14754 } 14755 } 14756 } 14757 setState(1731); 14758 _errHandler.sync(this); 14759 _alt = getInterpreter().adaptivePredict(_input,160,_ctx); 14760 } 14761 setState(1733); 14762 _errHandler.sync(this); 14763 switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) { 14764 case 1: 14765 { 14766 setState(1732); 14767 match(FIELD_NAME); 14768 } 14769 break; 14770 } 14771 setState(1738); 14772 _errHandler.sync(this); 14773 _alt = getInterpreter().adaptivePredict(_input,162,_ctx); 14774 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14775 if ( _alt==1 ) { 14776 { 14777 { 14778 setState(1735); 14779 _la = _input.LA(1); 14780 if ( !(_la==WS || _la==NEWLINE) ) { 14781 _errHandler.recoverInline(this); 14782 } 14783 else { 14784 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14785 _errHandler.reportMatch(this); 14786 consume(); 14787 } 14788 } 14789 } 14790 } 14791 setState(1740); 14792 _errHandler.sync(this); 14793 _alt = getInterpreter().adaptivePredict(_input,162,_ctx); 14794 } 14795 setState(1742); 14796 _errHandler.sync(this); 14797 switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) { 14798 case 1: 14799 { 14800 setState(1741); 14801 match(FIELD_TYPE); 14802 } 14803 break; 14804 } 14805 setState(1747); 14806 _errHandler.sync(this); 14807 _alt = getInterpreter().adaptivePredict(_input,164,_ctx); 14808 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14809 if ( _alt==1 ) { 14810 { 14811 { 14812 setState(1744); 14813 _la = _input.LA(1); 14814 if ( !(_la==WS || _la==NEWLINE) ) { 14815 _errHandler.recoverInline(this); 14816 } 14817 else { 14818 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14819 _errHandler.reportMatch(this); 14820 consume(); 14821 } 14822 } 14823 } 14824 } 14825 setState(1749); 14826 _errHandler.sync(this); 14827 _alt = getInterpreter().adaptivePredict(_input,164,_ctx); 14828 } 14829 setState(1751); 14830 _errHandler.sync(this); 14831 switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) { 14832 case 1: 14833 { 14834 setState(1750); 14835 description(); 14836 } 14837 break; 14838 } 14839 } 14840 break; 14841 case SINCE_LITERAL: 14842 enterOuterAlt(_localctx, 10); 14843 { 14844 setState(1753); 14845 match(SINCE_LITERAL); 14846 setState(1757); 14847 _errHandler.sync(this); 14848 _alt = getInterpreter().adaptivePredict(_input,166,_ctx); 14849 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14850 if ( _alt==1 ) { 14851 { 14852 { 14853 setState(1754); 14854 _la = _input.LA(1); 14855 if ( !(_la==WS || _la==NEWLINE) ) { 14856 _errHandler.recoverInline(this); 14857 } 14858 else { 14859 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14860 _errHandler.reportMatch(this); 14861 consume(); 14862 } 14863 } 14864 } 14865 } 14866 setState(1759); 14867 _errHandler.sync(this); 14868 _alt = getInterpreter().adaptivePredict(_input,166,_ctx); 14869 } 14870 setState(1761); 14871 _errHandler.sync(this); 14872 switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { 14873 case 1: 14874 { 14875 setState(1760); 14876 description(); 14877 } 14878 break; 14879 } 14880 } 14881 break; 14882 case THROWS_LITERAL: 14883 enterOuterAlt(_localctx, 11); 14884 { 14885 setState(1763); 14886 match(THROWS_LITERAL); 14887 setState(1767); 14888 _errHandler.sync(this); 14889 _alt = getInterpreter().adaptivePredict(_input,168,_ctx); 14890 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14891 if ( _alt==1 ) { 14892 { 14893 { 14894 setState(1764); 14895 _la = _input.LA(1); 14896 if ( !(_la==WS || _la==NEWLINE) ) { 14897 _errHandler.recoverInline(this); 14898 } 14899 else { 14900 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14901 _errHandler.reportMatch(this); 14902 consume(); 14903 } 14904 } 14905 } 14906 } 14907 setState(1769); 14908 _errHandler.sync(this); 14909 _alt = getInterpreter().adaptivePredict(_input,168,_ctx); 14910 } 14911 setState(1771); 14912 _errHandler.sync(this); 14913 switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) { 14914 case 1: 14915 { 14916 setState(1770); 14917 match(CLASS_NAME); 14918 } 14919 break; 14920 } 14921 setState(1776); 14922 _errHandler.sync(this); 14923 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14924 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14925 if ( _alt==1 ) { 14926 { 14927 { 14928 setState(1773); 14929 _la = _input.LA(1); 14930 if ( !(_la==WS || _la==NEWLINE) ) { 14931 _errHandler.recoverInline(this); 14932 } 14933 else { 14934 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14935 _errHandler.reportMatch(this); 14936 consume(); 14937 } 14938 } 14939 } 14940 } 14941 setState(1778); 14942 _errHandler.sync(this); 14943 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14944 } 14945 setState(1780); 14946 _errHandler.sync(this); 14947 switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) { 14948 case 1: 14949 { 14950 setState(1779); 14951 description(); 14952 } 14953 break; 14954 } 14955 } 14956 break; 14957 case VERSION_LITERAL: 14958 enterOuterAlt(_localctx, 12); 14959 { 14960 setState(1782); 14961 match(VERSION_LITERAL); 14962 setState(1786); 14963 _errHandler.sync(this); 14964 _alt = getInterpreter().adaptivePredict(_input,172,_ctx); 14965 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14966 if ( _alt==1 ) { 14967 { 14968 { 14969 setState(1783); 14970 _la = _input.LA(1); 14971 if ( !(_la==WS || _la==NEWLINE) ) { 14972 _errHandler.recoverInline(this); 14973 } 14974 else { 14975 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14976 _errHandler.reportMatch(this); 14977 consume(); 14978 } 14979 } 14980 } 14981 } 14982 setState(1788); 14983 _errHandler.sync(this); 14984 _alt = getInterpreter().adaptivePredict(_input,172,_ctx); 14985 } 14986 setState(1790); 14987 _errHandler.sync(this); 14988 switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) { 14989 case 1: 14990 { 14991 setState(1789); 14992 description(); 14993 } 14994 break; 14995 } 14996 } 14997 break; 14998 case CUSTOM_NAME: 14999 enterOuterAlt(_localctx, 13); 15000 { 15001 setState(1792); 15002 match(CUSTOM_NAME); 15003 setState(1796); 15004 _errHandler.sync(this); 15005 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 15006 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15007 if ( _alt==1 ) { 15008 { 15009 { 15010 setState(1793); 15011 _la = _input.LA(1); 15012 if ( !(_la==WS || _la==NEWLINE) ) { 15013 _errHandler.recoverInline(this); 15014 } 15015 else { 15016 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15017 _errHandler.reportMatch(this); 15018 consume(); 15019 } 15020 } 15021 } 15022 } 15023 setState(1798); 15024 _errHandler.sync(this); 15025 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 15026 } 15027 setState(1800); 15028 _errHandler.sync(this); 15029 switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) { 15030 case 1: 15031 { 15032 setState(1799); 15033 description(); 15034 } 15035 break; 15036 } 15037 } 15038 break; 15039 default: 15040 throw new NoViableAltException(this); 15041 } 15042 } 15043 catch (RecognitionException re) { 15044 _localctx.exception = re; 15045 _errHandler.reportError(this, re); 15046 _errHandler.recover(this, re); 15047 } 15048 finally { 15049 exitRule(); 15050 } 15051 return _localctx; 15052 } 15053 15054 public static class JavadocInlineTagContext extends ParserRuleContext { 15055 public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); } 15056 public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); } 15057 public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); } 15058 public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); } 15059 public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); } 15060 public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); } 15061 public ReferenceContext reference() { 15062 return getRuleContext(ReferenceContext.class,0); 15063 } 15064 public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); } 15065 public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); } 15066 public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); } 15067 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 15068 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15069 public TerminalNode WS(int i) { 15070 return getToken(JavadocParser.WS, i); 15071 } 15072 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15073 public TerminalNode NEWLINE(int i) { 15074 return getToken(JavadocParser.NEWLINE, i); 15075 } 15076 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15077 public TerminalNode LEADING_ASTERISK(int i) { 15078 return getToken(JavadocParser.LEADING_ASTERISK, i); 15079 } 15080 public List<TextContext> text() { 15081 return getRuleContexts(TextContext.class); 15082 } 15083 public TextContext text(int i) { 15084 return getRuleContext(TextContext.class,i); 15085 } 15086 public DescriptionContext description() { 15087 return getRuleContext(DescriptionContext.class,0); 15088 } 15089 public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) { 15090 super(parent, invokingState); 15091 } 15092 @Override public int getRuleIndex() { return RULE_javadocInlineTag; } 15093 @Override 15094 public void enterRule(ParseTreeListener listener) { 15095 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocInlineTag(this); 15096 } 15097 @Override 15098 public void exitRule(ParseTreeListener listener) { 15099 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocInlineTag(this); 15100 } 15101 @Override 15102 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15103 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocInlineTag(this); 15104 else return visitor.visitChildren(this); 15105 } 15106 } 15107 15108 public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException { 15109 JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState()); 15110 enterRule(_localctx, 144, RULE_javadocInlineTag); 15111 int _la; 15112 try { 15113 int _alt; 15114 enterOuterAlt(_localctx, 1); 15115 { 15116 setState(1804); 15117 match(JAVADOC_INLINE_TAG_START); 15118 setState(1881); 15119 _errHandler.sync(this); 15120 switch (_input.LA(1)) { 15121 case CODE_LITERAL: 15122 { 15123 setState(1805); 15124 match(CODE_LITERAL); 15125 setState(1812); 15126 _errHandler.sync(this); 15127 _la = _input.LA(1); 15128 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15129 { 15130 setState(1810); 15131 _errHandler.sync(this); 15132 switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) { 15133 case 1: 15134 { 15135 setState(1806); 15136 match(WS); 15137 } 15138 break; 15139 case 2: 15140 { 15141 setState(1807); 15142 match(NEWLINE); 15143 } 15144 break; 15145 case 3: 15146 { 15147 setState(1808); 15148 match(LEADING_ASTERISK); 15149 } 15150 break; 15151 case 4: 15152 { 15153 setState(1809); 15154 text(); 15155 } 15156 break; 15157 } 15158 } 15159 setState(1814); 15160 _errHandler.sync(this); 15161 _la = _input.LA(1); 15162 } 15163 } 15164 break; 15165 case DOC_ROOT_LITERAL: 15166 { 15167 setState(1815); 15168 match(DOC_ROOT_LITERAL); 15169 setState(1819); 15170 _errHandler.sync(this); 15171 _la = _input.LA(1); 15172 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15173 { 15174 { 15175 setState(1816); 15176 _la = _input.LA(1); 15177 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15178 _errHandler.recoverInline(this); 15179 } 15180 else { 15181 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15182 _errHandler.reportMatch(this); 15183 consume(); 15184 } 15185 } 15186 } 15187 setState(1821); 15188 _errHandler.sync(this); 15189 _la = _input.LA(1); 15190 } 15191 } 15192 break; 15193 case INHERIT_DOC_LITERAL: 15194 { 15195 setState(1822); 15196 match(INHERIT_DOC_LITERAL); 15197 setState(1826); 15198 _errHandler.sync(this); 15199 _la = _input.LA(1); 15200 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15201 { 15202 { 15203 setState(1823); 15204 _la = _input.LA(1); 15205 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15206 _errHandler.recoverInline(this); 15207 } 15208 else { 15209 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15210 _errHandler.reportMatch(this); 15211 consume(); 15212 } 15213 } 15214 } 15215 setState(1828); 15216 _errHandler.sync(this); 15217 _la = _input.LA(1); 15218 } 15219 } 15220 break; 15221 case LINK_LITERAL: 15222 { 15223 setState(1829); 15224 match(LINK_LITERAL); 15225 setState(1833); 15226 _errHandler.sync(this); 15227 _la = _input.LA(1); 15228 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15229 { 15230 { 15231 setState(1830); 15232 _la = _input.LA(1); 15233 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15234 _errHandler.recoverInline(this); 15235 } 15236 else { 15237 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15238 _errHandler.reportMatch(this); 15239 consume(); 15240 } 15241 } 15242 } 15243 setState(1835); 15244 _errHandler.sync(this); 15245 _la = _input.LA(1); 15246 } 15247 setState(1836); 15248 reference(); 15249 setState(1838); 15250 _errHandler.sync(this); 15251 switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { 15252 case 1: 15253 { 15254 setState(1837); 15255 description(); 15256 } 15257 break; 15258 } 15259 } 15260 break; 15261 case LINKPLAIN_LITERAL: 15262 { 15263 setState(1840); 15264 match(LINKPLAIN_LITERAL); 15265 setState(1844); 15266 _errHandler.sync(this); 15267 _la = _input.LA(1); 15268 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15269 { 15270 { 15271 setState(1841); 15272 _la = _input.LA(1); 15273 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15274 _errHandler.recoverInline(this); 15275 } 15276 else { 15277 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15278 _errHandler.reportMatch(this); 15279 consume(); 15280 } 15281 } 15282 } 15283 setState(1846); 15284 _errHandler.sync(this); 15285 _la = _input.LA(1); 15286 } 15287 setState(1847); 15288 reference(); 15289 setState(1849); 15290 _errHandler.sync(this); 15291 switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) { 15292 case 1: 15293 { 15294 setState(1848); 15295 description(); 15296 } 15297 break; 15298 } 15299 } 15300 break; 15301 case LITERAL_LITERAL: 15302 { 15303 setState(1851); 15304 match(LITERAL_LITERAL); 15305 setState(1858); 15306 _errHandler.sync(this); 15307 _la = _input.LA(1); 15308 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15309 { 15310 setState(1856); 15311 _errHandler.sync(this); 15312 switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) { 15313 case 1: 15314 { 15315 setState(1852); 15316 match(WS); 15317 } 15318 break; 15319 case 2: 15320 { 15321 setState(1853); 15322 match(NEWLINE); 15323 } 15324 break; 15325 case 3: 15326 { 15327 setState(1854); 15328 match(LEADING_ASTERISK); 15329 } 15330 break; 15331 case 4: 15332 { 15333 setState(1855); 15334 text(); 15335 } 15336 break; 15337 } 15338 } 15339 setState(1860); 15340 _errHandler.sync(this); 15341 _la = _input.LA(1); 15342 } 15343 } 15344 break; 15345 case VALUE_LITERAL: 15346 { 15347 setState(1861); 15348 match(VALUE_LITERAL); 15349 setState(1865); 15350 _errHandler.sync(this); 15351 _la = _input.LA(1); 15352 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15353 { 15354 { 15355 setState(1862); 15356 _la = _input.LA(1); 15357 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15358 _errHandler.recoverInline(this); 15359 } 15360 else { 15361 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15362 _errHandler.reportMatch(this); 15363 consume(); 15364 } 15365 } 15366 } 15367 setState(1867); 15368 _errHandler.sync(this); 15369 _la = _input.LA(1); 15370 } 15371 setState(1869); 15372 _errHandler.sync(this); 15373 _la = _input.LA(1); 15374 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << DOT) | (1L << HASH) | (1L << CLASS) | (1L << MEMBER))) != 0)) { 15375 { 15376 setState(1868); 15377 reference(); 15378 } 15379 } 15380 15381 } 15382 break; 15383 case CUSTOM_NAME: 15384 { 15385 setState(1871); 15386 match(CUSTOM_NAME); 15387 setState(1875); 15388 _errHandler.sync(this); 15389 _alt = getInterpreter().adaptivePredict(_input,189,_ctx); 15390 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15391 if ( _alt==1 ) { 15392 { 15393 { 15394 setState(1872); 15395 _la = _input.LA(1); 15396 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15397 _errHandler.recoverInline(this); 15398 } 15399 else { 15400 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15401 _errHandler.reportMatch(this); 15402 consume(); 15403 } 15404 } 15405 } 15406 } 15407 setState(1877); 15408 _errHandler.sync(this); 15409 _alt = getInterpreter().adaptivePredict(_input,189,_ctx); 15410 } 15411 setState(1879); 15412 _errHandler.sync(this); 15413 switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) { 15414 case 1: 15415 { 15416 setState(1878); 15417 description(); 15418 } 15419 break; 15420 } 15421 } 15422 break; 15423 default: 15424 throw new NoViableAltException(this); 15425 } 15426 setState(1883); 15427 match(JAVADOC_INLINE_TAG_END); 15428 } 15429 } 15430 catch (RecognitionException re) { 15431 _localctx.exception = re; 15432 _errHandler.reportError(this, re); 15433 _errHandler.recover(this, re); 15434 } 15435 finally { 15436 exitRule(); 15437 } 15438 return _localctx; 15439 } 15440 15441 public static class HtmlCommentContext extends ParserRuleContext { 15442 public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); } 15443 public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); } 15444 public List<TextContext> text() { 15445 return getRuleContexts(TextContext.class); 15446 } 15447 public TextContext text(int i) { 15448 return getRuleContext(TextContext.class,i); 15449 } 15450 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15451 public TerminalNode NEWLINE(int i) { 15452 return getToken(JavadocParser.NEWLINE, i); 15453 } 15454 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15455 public TerminalNode LEADING_ASTERISK(int i) { 15456 return getToken(JavadocParser.LEADING_ASTERISK, i); 15457 } 15458 public HtmlCommentContext(ParserRuleContext parent, int invokingState) { 15459 super(parent, invokingState); 15460 } 15461 @Override public int getRuleIndex() { return RULE_htmlComment; } 15462 @Override 15463 public void enterRule(ParseTreeListener listener) { 15464 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlComment(this); 15465 } 15466 @Override 15467 public void exitRule(ParseTreeListener listener) { 15468 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlComment(this); 15469 } 15470 @Override 15471 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15472 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlComment(this); 15473 else return visitor.visitChildren(this); 15474 } 15475 } 15476 15477 public final HtmlCommentContext htmlComment() throws RecognitionException { 15478 HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState()); 15479 enterRule(_localctx, 146, RULE_htmlComment); 15480 int _la; 15481 try { 15482 enterOuterAlt(_localctx, 1); 15483 { 15484 setState(1885); 15485 match(HTML_COMMENT_START); 15486 setState(1891); 15487 _errHandler.sync(this); 15488 _la = _input.LA(1); 15489 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15490 { 15491 setState(1889); 15492 _errHandler.sync(this); 15493 switch (_input.LA(1)) { 15494 case WS: 15495 case CHAR: 15496 { 15497 setState(1886); 15498 text(); 15499 } 15500 break; 15501 case NEWLINE: 15502 { 15503 setState(1887); 15504 match(NEWLINE); 15505 } 15506 break; 15507 case LEADING_ASTERISK: 15508 { 15509 setState(1888); 15510 match(LEADING_ASTERISK); 15511 } 15512 break; 15513 default: 15514 throw new NoViableAltException(this); 15515 } 15516 } 15517 setState(1893); 15518 _errHandler.sync(this); 15519 _la = _input.LA(1); 15520 } 15521 setState(1894); 15522 match(HTML_COMMENT_END); 15523 } 15524 } 15525 catch (RecognitionException re) { 15526 _localctx.exception = re; 15527 _errHandler.reportError(this, re); 15528 _errHandler.recover(this, re); 15529 } 15530 finally { 15531 exitRule(); 15532 } 15533 return _localctx; 15534 } 15535 15536 public static class TextContext extends ParserRuleContext { 15537 public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); } 15538 public TerminalNode CHAR(int i) { 15539 return getToken(JavadocParser.CHAR, i); 15540 } 15541 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15542 public TerminalNode WS(int i) { 15543 return getToken(JavadocParser.WS, i); 15544 } 15545 public TextContext(ParserRuleContext parent, int invokingState) { 15546 super(parent, invokingState); 15547 } 15548 @Override public int getRuleIndex() { return RULE_text; } 15549 @Override 15550 public void enterRule(ParseTreeListener listener) { 15551 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterText(this); 15552 } 15553 @Override 15554 public void exitRule(ParseTreeListener listener) { 15555 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitText(this); 15556 } 15557 @Override 15558 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15559 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitText(this); 15560 else return visitor.visitChildren(this); 15561 } 15562 } 15563 15564 public final TextContext text() throws RecognitionException { 15565 TextContext _localctx = new TextContext(_ctx, getState()); 15566 enterRule(_localctx, 148, RULE_text); 15567 int _la; 15568 try { 15569 int _alt; 15570 enterOuterAlt(_localctx, 1); 15571 { 15572 setState(1898); 15573 _errHandler.sync(this); 15574 _alt = 1; 15575 do { 15576 switch (_alt) { 15577 case 1: 15578 { 15579 { 15580 setState(1896); 15581 _la = _input.LA(1); 15582 if ( !(_la==WS || _la==CHAR) ) { 15583 _errHandler.recoverInline(this); 15584 } 15585 else { 15586 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15587 _errHandler.reportMatch(this); 15588 consume(); 15589 } 15590 15591 _la = _input.LA(1); 15592 if ((_la != WS) && (_la != CHAR)) return _localctx; 15593 else if (_alt == 1) continue; 15594 15595 } 15596 } 15597 break; 15598 default: 15599 throw new NoViableAltException(this); 15600 } 15601 setState(1900); 15602 _errHandler.sync(this); 15603 _alt = getInterpreter().adaptivePredict(_input,194,_ctx); 15604 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15605 } 15606 } 15607 catch (RecognitionException re) { 15608 _localctx.exception = re; 15609 _errHandler.reportError(this, re); 15610 _errHandler.recover(this, re); 15611 } 15612 finally { 15613 exitRule(); 15614 } 15615 return _localctx; 15616 } 15617 15618 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { 15619 switch (ruleIndex) { 15620 case 0: 15621 return javadoc_sempred((JavadocContext)_localctx, predIndex); 15622 case 5: 15623 return htmlTag_sempred((HtmlTagContext)_localctx, predIndex); 15624 case 8: 15625 return paragraph_sempred((ParagraphContext)_localctx, predIndex); 15626 case 11: 15627 return li_sempred((LiContext)_localctx, predIndex); 15628 case 14: 15629 return tr_sempred((TrContext)_localctx, predIndex); 15630 case 17: 15631 return td_sempred((TdContext)_localctx, predIndex); 15632 case 20: 15633 return th_sempred((ThContext)_localctx, predIndex); 15634 case 23: 15635 return body_sempred((BodyContext)_localctx, predIndex); 15636 case 26: 15637 return colgroup_sempred((ColgroupContext)_localctx, predIndex); 15638 case 29: 15639 return dd_sempred((DdContext)_localctx, predIndex); 15640 case 32: 15641 return dt_sempred((DtContext)_localctx, predIndex); 15642 case 35: 15643 return head_sempred((HeadContext)_localctx, predIndex); 15644 case 38: 15645 return html_sempred((HtmlContext)_localctx, predIndex); 15646 case 41: 15647 return option_sempred((OptionContext)_localctx, predIndex); 15648 case 44: 15649 return tbody_sempred((TbodyContext)_localctx, predIndex); 15650 case 47: 15651 return tfoot_sempred((TfootContext)_localctx, predIndex); 15652 case 50: 15653 return thead_sempred((TheadContext)_localctx, predIndex); 15654 case 68: 15655 return description_sempred((DescriptionContext)_localctx, predIndex); 15656 } 15657 return true; 15658 } 15659 private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) { 15660 switch (predIndex) { 15661 case 0: 15662 return !isNextJavadocTag(); 15663 } 15664 return true; 15665 } 15666 private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) { 15667 switch (predIndex) { 15668 case 1: 15669 return !isNextJavadocTag(); 15670 case 2: 15671 return !isNextJavadocTag(); 15672 } 15673 return true; 15674 } 15675 private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) { 15676 switch (predIndex) { 15677 case 3: 15678 return !isNextJavadocTag(); 15679 } 15680 return true; 15681 } 15682 private boolean li_sempred(LiContext _localctx, int predIndex) { 15683 switch (predIndex) { 15684 case 4: 15685 return !isNextJavadocTag(); 15686 } 15687 return true; 15688 } 15689 private boolean tr_sempred(TrContext _localctx, int predIndex) { 15690 switch (predIndex) { 15691 case 5: 15692 return !isNextJavadocTag(); 15693 } 15694 return true; 15695 } 15696 private boolean td_sempred(TdContext _localctx, int predIndex) { 15697 switch (predIndex) { 15698 case 6: 15699 return !isNextJavadocTag(); 15700 } 15701 return true; 15702 } 15703 private boolean th_sempred(ThContext _localctx, int predIndex) { 15704 switch (predIndex) { 15705 case 7: 15706 return !isNextJavadocTag(); 15707 } 15708 return true; 15709 } 15710 private boolean body_sempred(BodyContext _localctx, int predIndex) { 15711 switch (predIndex) { 15712 case 8: 15713 return !isNextJavadocTag(); 15714 } 15715 return true; 15716 } 15717 private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) { 15718 switch (predIndex) { 15719 case 9: 15720 return !isNextJavadocTag(); 15721 } 15722 return true; 15723 } 15724 private boolean dd_sempred(DdContext _localctx, int predIndex) { 15725 switch (predIndex) { 15726 case 10: 15727 return !isNextJavadocTag(); 15728 } 15729 return true; 15730 } 15731 private boolean dt_sempred(DtContext _localctx, int predIndex) { 15732 switch (predIndex) { 15733 case 11: 15734 return !isNextJavadocTag(); 15735 } 15736 return true; 15737 } 15738 private boolean head_sempred(HeadContext _localctx, int predIndex) { 15739 switch (predIndex) { 15740 case 12: 15741 return !isNextJavadocTag(); 15742 } 15743 return true; 15744 } 15745 private boolean html_sempred(HtmlContext _localctx, int predIndex) { 15746 switch (predIndex) { 15747 case 13: 15748 return !isNextJavadocTag(); 15749 } 15750 return true; 15751 } 15752 private boolean option_sempred(OptionContext _localctx, int predIndex) { 15753 switch (predIndex) { 15754 case 14: 15755 return !isNextJavadocTag(); 15756 } 15757 return true; 15758 } 15759 private boolean tbody_sempred(TbodyContext _localctx, int predIndex) { 15760 switch (predIndex) { 15761 case 15: 15762 return !isNextJavadocTag(); 15763 } 15764 return true; 15765 } 15766 private boolean tfoot_sempred(TfootContext _localctx, int predIndex) { 15767 switch (predIndex) { 15768 case 16: 15769 return !isNextJavadocTag(); 15770 } 15771 return true; 15772 } 15773 private boolean thead_sempred(TheadContext _localctx, int predIndex) { 15774 switch (predIndex) { 15775 case 17: 15776 return !isNextJavadocTag(); 15777 } 15778 return true; 15779 } 15780 private boolean description_sempred(DescriptionContext _localctx, int predIndex) { 15781 switch (predIndex) { 15782 case 18: 15783 return !isNextJavadocTag(); 15784 } 15785 return true; 15786 } 15787 15788 public static final String _serializedATN = 15789 "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3]\u0771\4\2\t\2\4"+ 15790 "\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"+ 15791 "\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"+ 15792 "\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"+ 15793 "\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!"+ 15794 "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ 15795 ",\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"+ 15796 "\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="+ 15797 "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ 15798 "\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"+ 15799 "\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"+ 15800 "\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"+ 15801 "\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"+ 15802 "\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+ 15803 "\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u00e6\n\3\3\4\3\4\3\4\3\4\3\4\3\4\7"+ 15804 "\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"+ 15805 "\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"+ 15806 "\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"+ 15807 "\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"+ 15808 "\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"+ 15809 "\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"+ 15810 "\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"+ 15811 "\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"+ 15812 "\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"+ 15813 "\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"+ 15814 "\13\3\13\3\13\3\13\3\13\3\13\7\13\u0180\n\13\f\13\16\13\u0183\13\13\3"+ 15815 "\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"+ 15816 "\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"+ 15817 "\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"+ 15818 "\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"+ 15819 "\3\16\3\16\7\16\u01c5\n\16\f\16\16\16\u01c8\13\16\3\16\3\16\3\17\3\17"+ 15820 "\3\17\3\17\7\17\u01d0\n\17\f\17\16\17\u01d3\13\17\3\17\3\17\3\20\3\20"+ 15821 "\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"+ 15822 "\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20"+ 15823 "\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u01fd\n\20\f\20\16\20\u0200"+ 15824 "\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"+ 15825 "\21\u020d\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0215\n\22\f\22\16"+ 15826 "\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"+ 15827 "\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"+ 15828 "\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23"+ 15829 "\3\23\7\23\u0242\n\23\f\23\16\23\u0245\13\23\3\23\3\23\3\24\3\24\3\24"+ 15830 "\3\24\3\24\3\24\7\24\u024f\n\24\f\24\16\24\u0252\13\24\3\24\3\24\3\25"+ 15831 "\3\25\3\25\3\25\7\25\u025a\n\25\f\25\16\25\u025d\13\25\3\25\3\25\3\26"+ 15832 "\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"+ 15833 "\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26"+ 15834 "\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\7\26\u0287\n\26\f\26\16"+ 15835 "\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"+ 15836 "\f\27\16\27\u0297\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u029f\n\30"+ 15837 "\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"+ 15838 "\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"+ 15839 "\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3"+ 15840 "\31\3\31\3\31\7\31\u02cc\n\31\f\31\16\31\u02cf\13\31\3\31\3\31\3\32\3"+ 15841 "\32\3\32\3\32\3\32\3\32\7\32\u02d9\n\32\f\32\16\32\u02dc\13\32\3\32\3"+ 15842 "\32\3\33\3\33\3\33\3\33\7\33\u02e4\n\33\f\33\16\33\u02e7\13\33\3\33\3"+ 15843 "\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"+ 15844 "\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"+ 15845 "\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"+ 15846 "\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"+ 15847 "\n\35\f\35\16\35\u0321\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0329"+ 15848 "\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"+ 15849 "\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"+ 15850 "\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3"+ 15851 "\37\3\37\3\37\3\37\7\37\u0356\n\37\f\37\16\37\u0359\13\37\3\37\3\37\3"+ 15852 " \3 \3 \3 \3 \3 \7 \u0363\n \f \16 \u0366\13 \3 \3 \3!\3!\3!\3!\7!\u036e"+ 15853 "\n!\f!\16!\u0371\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+ 15854 "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+ 15855 "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u039b\n\"\f\"\16\"\u039e\13"+ 15856 "\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u03a8\n#\f#\16#\u03ab\13#\3#\3#\3$\3$"+ 15857 "\3$\3$\7$\u03b3\n$\f$\16$\u03b6\13$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 15858 "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 15859 "%\3%\3%\3%\3%\3%\7%\u03e0\n%\f%\16%\u03e3\13%\3%\3%\3&\3&\3&\3&\3&\3&"+ 15860 "\7&\u03ed\n&\f&\16&\u03f0\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u03f8\n\'\f\'"+ 15861 "\16\'\u03fb\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+ 15862 "\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+ 15863 "\7(\u0425\n(\f(\16(\u0428\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u0432\n)\f)\16"+ 15864 ")\u0435\13)\3)\3)\3*\3*\3*\3*\7*\u043d\n*\f*\16*\u0440\13*\3*\3*\3+\3"+ 15865 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3"+ 15866 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\7+\u046a\n+\f+\16+\u046d\13+"+ 15867 "\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0477\n,\f,\16,\u047a\13,\3,\3,\3-\3-\3-\3"+ 15868 "-\7-\u0482\n-\f-\16-\u0485\13-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+ 15869 "\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+ 15870 "\3.\3.\3.\3.\7.\u04af\n.\f.\16.\u04b2\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u04bc"+ 15871 "\n/\f/\16/\u04bf\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u04c7\n\60\f\60\16"+ 15872 "\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"+ 15873 "\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"+ 15874 "\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61\3\61"+ 15875 "\3\61\7\61\u04f4\n\61\f\61\16\61\u04f7\13\61\3\61\3\61\3\62\3\62\3\62"+ 15876 "\3\62\3\62\3\62\7\62\u0501\n\62\f\62\16\62\u0504\13\62\3\62\3\62\3\63"+ 15877 "\3\63\3\63\3\63\7\63\u050c\n\63\f\63\16\63\u050f\13\63\3\63\3\63\3\64"+ 15878 "\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"+ 15879 "\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64"+ 15880 "\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\7\64\u0539\n\64\f\64\16"+ 15881 "\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"+ 15882 "\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"+ 15883 "\3\66\7\66\u0557\n\66\f\66\16\66\u055a\13\66\3\66\3\66\3\67\3\67\3\67"+ 15884 "\3\67\3\67\3\67\7\67\u0564\n\67\f\67\16\67\u0567\13\67\3\67\3\67\38\3"+ 15885 "8\38\38\38\38\78\u0571\n8\f8\168\u0574\138\38\38\39\39\39\39\39\39\79"+ 15886 "\u057e\n9\f9\169\u0581\139\39\39\3:\3:\3:\3:\3:\3:\7:\u058b\n:\f:\16:"+ 15887 "\u058e\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0598\n;\f;\16;\u059b\13;\3;\3;"+ 15888 "\3<\3<\3<\3<\3<\3<\7<\u05a5\n<\f<\16<\u05a8\13<\3<\3<\3=\3=\3=\3=\3=\3"+ 15889 "=\7=\u05b2\n=\f=\16=\u05b5\13=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u05bf\n>\f>"+ 15890 "\16>\u05c2\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u05cc\n?\f?\16?\u05cf\13?\3"+ 15891 "?\3?\3@\3@\3@\3@\3@\3@\7@\u05d9\n@\f@\16@\u05dc\13@\3@\3@\3A\3A\3A\3A"+ 15892 "\3A\3A\7A\u05e6\nA\fA\16A\u05e9\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u05f3\n"+ 15893 "B\fB\16B\u05f6\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u0600\nC\fC\16C\u0603\13"+ 15894 "C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u0617\nF\r"+ 15895 "F\16F\u0618\3G\3G\7G\u061d\nG\fG\16G\u0620\13G\3G\5G\u0623\nG\3G\5G\u0626"+ 15896 "\nG\3G\5G\u0629\nG\3G\6G\u062c\nG\rG\16G\u062d\3G\5G\u0631\nG\3G\5G\u0634"+ 15897 "\nG\3G\5G\u0637\nG\3G\5G\u063a\nG\3G\3G\5G\u063e\nG\5G\u0640\nG\3H\3H"+ 15898 "\7H\u0644\nH\fH\16H\u0647\13H\3H\3H\3I\3I\7I\u064d\nI\fI\16I\u0650\13"+ 15899 "I\3I\5I\u0653\nI\3I\3I\7I\u0657\nI\fI\16I\u065a\13I\3I\5I\u065d\nI\3I"+ 15900 "\3I\7I\u0661\nI\fI\16I\u0664\13I\3I\5I\u0667\nI\3I\7I\u066a\nI\fI\16I"+ 15901 "\u066d\13I\3I\5I\u0670\nI\3I\3I\7I\u0674\nI\fI\16I\u0677\13I\3I\5I\u067a"+ 15902 "\nI\3I\7I\u067d\nI\fI\16I\u0680\13I\3I\5I\u0683\nI\3I\3I\7I\u0687\nI\f"+ 15903 "I\16I\u068a\13I\3I\5I\u068d\nI\3I\3I\7I\u0691\nI\fI\16I\u0694\13I\3I\5"+ 15904 "I\u0697\nI\3I\3I\7I\u069b\nI\fI\16I\u069e\13I\3I\7I\u06a1\nI\fI\16I\u06a4"+ 15905 "\13I\3I\5I\u06a7\nI\3I\3I\7I\u06ab\nI\fI\16I\u06ae\13I\3I\5I\u06b1\nI"+ 15906 "\3I\5I\u06b4\nI\3I\3I\7I\u06b8\nI\fI\16I\u06bb\13I\3I\5I\u06be\nI\3I\3"+ 15907 "I\7I\u06c2\nI\fI\16I\u06c5\13I\3I\5I\u06c8\nI\3I\7I\u06cb\nI\fI\16I\u06ce"+ 15908 "\13I\3I\5I\u06d1\nI\3I\7I\u06d4\nI\fI\16I\u06d7\13I\3I\5I\u06da\nI\3I"+ 15909 "\3I\7I\u06de\nI\fI\16I\u06e1\13I\3I\5I\u06e4\nI\3I\3I\7I\u06e8\nI\fI\16"+ 15910 "I\u06eb\13I\3I\5I\u06ee\nI\3I\7I\u06f1\nI\fI\16I\u06f4\13I\3I\5I\u06f7"+ 15911 "\nI\3I\3I\7I\u06fb\nI\fI\16I\u06fe\13I\3I\5I\u0701\nI\3I\3I\7I\u0705\n"+ 15912 "I\fI\16I\u0708\13I\3I\5I\u070b\nI\5I\u070d\nI\3J\3J\3J\3J\3J\3J\7J\u0715"+ 15913 "\nJ\fJ\16J\u0718\13J\3J\3J\7J\u071c\nJ\fJ\16J\u071f\13J\3J\3J\7J\u0723"+ 15914 "\nJ\fJ\16J\u0726\13J\3J\3J\7J\u072a\nJ\fJ\16J\u072d\13J\3J\3J\5J\u0731"+ 15915 "\nJ\3J\3J\7J\u0735\nJ\fJ\16J\u0738\13J\3J\3J\5J\u073c\nJ\3J\3J\3J\3J\3"+ 15916 "J\7J\u0743\nJ\fJ\16J\u0746\13J\3J\3J\7J\u074a\nJ\fJ\16J\u074d\13J\3J\5"+ 15917 "J\u0750\nJ\3J\3J\7J\u0754\nJ\fJ\16J\u0757\13J\3J\5J\u075a\nJ\5J\u075c"+ 15918 "\nJ\3J\3J\3K\3K\3K\3K\7K\u0764\nK\fK\16K\u0767\13K\3K\3K\3L\3L\6L\u076d"+ 15919 "\nL\rL\16L\u076e\3L\2\2M\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&("+ 15920 "*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084"+ 15921 "\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\2\13\5\2\3\3\6"+ 15922 "\6\b\b\4\2=KYY\3\29:\3\2LX\4\2\37\37!!\6\2\3\3\6\6\b\b&\'\4\2\6\6\b\b"+ 15923 "\3\2\30\31\4\2\6\6\32\32\2\u0a88\2\u00a2\3\2\2\2\4\u00e5\3\2\2\2\6\u00e7"+ 15924 "\3\2\2\2\b\u00f4\3\2\2\2\n\u00ff\3\2\2\2\f\u0132\3\2\2\2\16\u0134\3\2"+ 15925 "\2\2\20\u0141\3\2\2\2\22\u014c\3\2\2\2\24\u0179\3\2\2\2\26\u0186\3\2\2"+ 15926 "\2\30\u0191\3\2\2\2\32\u01be\3\2\2\2\34\u01cb\3\2\2\2\36\u01d6\3\2\2\2"+ 15927 " \u0203\3\2\2\2\"\u0210\3\2\2\2$\u021b\3\2\2\2&\u0248\3\2\2\2(\u0255\3"+ 15928 "\2\2\2*\u0260\3\2\2\2,\u028d\3\2\2\2.\u029a\3\2\2\2\60\u02a5\3\2\2\2\62"+ 15929 "\u02d2\3\2\2\2\64\u02df\3\2\2\2\66\u02ea\3\2\2\28\u0317\3\2\2\2:\u0324"+ 15930 "\3\2\2\2<\u032f\3\2\2\2>\u035c\3\2\2\2@\u0369\3\2\2\2B\u0374\3\2\2\2D"+ 15931 "\u03a1\3\2\2\2F\u03ae\3\2\2\2H\u03b9\3\2\2\2J\u03e6\3\2\2\2L\u03f3\3\2"+ 15932 "\2\2N\u03fe\3\2\2\2P\u042b\3\2\2\2R\u0438\3\2\2\2T\u0443\3\2\2\2V\u0470"+ 15933 "\3\2\2\2X\u047d\3\2\2\2Z\u0488\3\2\2\2\\\u04b5\3\2\2\2^\u04c2\3\2\2\2"+ 15934 "`\u04cd\3\2\2\2b\u04fa\3\2\2\2d\u0507\3\2\2\2f\u0512\3\2\2\2h\u054e\3"+ 15935 "\2\2\2j\u0550\3\2\2\2l\u055d\3\2\2\2n\u056a\3\2\2\2p\u0577\3\2\2\2r\u0584"+ 15936 "\3\2\2\2t\u0591\3\2\2\2v\u059e\3\2\2\2x\u05ab\3\2\2\2z\u05b8\3\2\2\2|"+ 15937 "\u05c5\3\2\2\2~\u05d2\3\2\2\2\u0080\u05df\3\2\2\2\u0082\u05ec\3\2\2\2"+ 15938 "\u0084\u05f9\3\2\2\2\u0086\u0606\3\2\2\2\u0088\u060c\3\2\2\2\u008a\u0616"+ 15939 "\3\2\2\2\u008c\u063f\3\2\2\2\u008e\u0641\3\2\2\2\u0090\u070c\3\2\2\2\u0092"+ 15940 "\u070e\3\2\2\2\u0094\u075f\3\2\2\2\u0096\u076c\3\2\2\2\u0098\u00a1\5\4"+ 15941 "\3\2\u0099\u009a\6\2\2\2\u009a\u00a1\7\3\2\2\u009b\u00a1\5\u0094K\2\u009c"+ 15942 "\u00a1\7\5\2\2\u009d\u00a1\7\b\2\2\u009e\u00a1\5\u0096L\2\u009f\u00a1"+ 15943 "\5\u0092J\2\u00a0\u0098\3\2\2\2\u00a0\u0099\3\2\2\2\u00a0\u009b\3\2\2"+ 15944 "\2\u00a0\u009c\3\2\2\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u009f"+ 15945 "\3\2\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3"+ 15946 "\u00b1\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a7\7\3\2\2\u00a6\u00a5\3\2"+ 15947 "\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00ab\3\2\2\2\u00a8\u00aa\7\6\2\2\u00a9"+ 15948 "\u00a8\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2"+ 15949 "\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00b0\5\u0090I\2\u00af"+ 15950 "\u00a6\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2"+ 15951 "\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5\7\2\2\3\u00b5"+ 15952 "\3\3\2\2\2\u00b6\u00e6\5\f\7\2\u00b7\u00e6\5h\65\2\u00b8\u00e6\5\22\n"+ 15953 "\2\u00b9\u00e6\5\30\r\2\u00ba\u00e6\5\36\20\2\u00bb\u00e6\5$\23\2\u00bc"+ 15954 "\u00e6\5*\26\2\u00bd\u00e6\5\60\31\2\u00be\u00e6\5\66\34\2\u00bf\u00e6"+ 15955 "\5<\37\2\u00c0\u00e6\5B\"\2\u00c1\u00e6\5H%\2\u00c2\u00e6\5N(\2\u00c3"+ 15956 "\u00e6\5T+\2\u00c4\u00e6\5Z.\2\u00c5\u00e6\5f\64\2\u00c6\u00e6\5`\61\2"+ 15957 "\u00c7\u00e6\5\16\b\2\u00c8\u00e6\5\24\13\2\u00c9\u00e6\5\32\16\2\u00ca"+ 15958 "\u00e6\5 \21\2\u00cb\u00e6\5&\24\2\u00cc\u00e6\5,\27\2\u00cd\u00e6\5\62"+ 15959 "\32\2\u00ce\u00e6\58\35\2\u00cf\u00e6\5> \2\u00d0\u00e6\5D#\2\u00d1\u00e6"+ 15960 "\5J&\2\u00d2\u00e6\5P)\2\u00d3\u00e6\5V,\2\u00d4\u00e6\5b\62\2\u00d5\u00e6"+ 15961 "\5\\/\2\u00d6\u00e6\5\20\t\2\u00d7\u00e6\5\26\f\2\u00d8\u00e6\5\34\17"+ 15962 "\2\u00d9\u00e6\5\"\22\2\u00da\u00e6\5(\25\2\u00db\u00e6\5.\30\2\u00dc"+ 15963 "\u00e6\5\64\33\2\u00dd\u00e6\5:\36\2\u00de\u00e6\5@!\2\u00df\u00e6\5F"+ 15964 "$\2\u00e0\u00e6\5L\'\2\u00e1\u00e6\5R*\2\u00e2\u00e6\5X-\2\u00e3\u00e6"+ 15965 "\5d\63\2\u00e4\u00e6\5^\60\2\u00e5\u00b6\3\2\2\2\u00e5\u00b7\3\2\2\2\u00e5"+ 15966 "\u00b8\3\2\2\2\u00e5\u00b9\3\2\2\2\u00e5\u00ba\3\2\2\2\u00e5\u00bb\3\2"+ 15967 "\2\2\u00e5\u00bc\3\2\2\2\u00e5\u00bd\3\2\2\2\u00e5\u00be\3\2\2\2\u00e5"+ 15968 "\u00bf\3\2\2\2\u00e5\u00c0\3\2\2\2\u00e5\u00c1\3\2\2\2\u00e5\u00c2\3\2"+ 15969 "\2\2\u00e5\u00c3\3\2\2\2\u00e5\u00c4\3\2\2\2\u00e5\u00c5\3\2\2\2\u00e5"+ 15970 "\u00c6\3\2\2\2\u00e5\u00c7\3\2\2\2\u00e5\u00c8\3\2\2\2\u00e5\u00c9\3\2"+ 15971 "\2\2\u00e5\u00ca\3\2\2\2\u00e5\u00cb\3\2\2\2\u00e5\u00cc\3\2\2\2\u00e5"+ 15972 "\u00cd\3\2\2\2\u00e5\u00ce\3\2\2\2\u00e5\u00cf\3\2\2\2\u00e5\u00d0\3\2"+ 15973 "\2\2\u00e5\u00d1\3\2\2\2\u00e5\u00d2\3\2\2\2\u00e5\u00d3\3\2\2\2\u00e5"+ 15974 "\u00d4\3\2\2\2\u00e5\u00d5\3\2\2\2\u00e5\u00d6\3\2\2\2\u00e5\u00d7\3\2"+ 15975 "\2\2\u00e5\u00d8\3\2\2\2\u00e5\u00d9\3\2\2\2\u00e5\u00da\3\2\2\2\u00e5"+ 15976 "\u00db\3\2\2\2\u00e5\u00dc\3\2\2\2\u00e5\u00dd\3\2\2\2\u00e5\u00de\3\2"+ 15977 "\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2\u00e5\u00e1\3\2\2\2\u00e5"+ 15978 "\u00e2\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4\3\2\2\2\u00e6\5\3\2\2\2"+ 15979 "\u00e7\u00e8\7\7\2\2\u00e8\u00ef\7Y\2\2\u00e9\u00ee\5\n\6\2\u00ea\u00ee"+ 15980 "\7\b\2\2\u00eb\u00ee\7\3\2\2\u00ec\u00ee\7\6\2\2\u00ed\u00e9\3\2\2\2\u00ed"+ 15981 "\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec\3\2\2\2\u00ee\u00f1\3\2"+ 15982 "\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\3\2\2\2\u00f1"+ 15983 "\u00ef\3\2\2\2\u00f2\u00f3\79\2\2\u00f3\7\3\2\2\2\u00f4\u00f5\7\7\2\2"+ 15984 "\u00f5\u00f6\7;\2\2\u00f6\u00fa\7Y\2\2\u00f7\u00f9\t\2\2\2\u00f8\u00f7"+ 15985 "\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb"+ 15986 "\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\79\2\2\u00fe\t\3\2\2\2"+ 15987 "\u00ff\u0103\7Y\2\2\u0100\u0102\t\2\2\2\u0101\u0100\3\2\2\2\u0102\u0105"+ 15988 "\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105"+ 15989 "\u0103\3\2\2\2\u0106\u010a\7<\2\2\u0107\u0109\t\2\2\2\u0108\u0107\3\2"+ 15990 "\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b"+ 15991 "\u0110\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0111\7[\2\2\u010e\u0111\5\u0096"+ 15992 "L\2\u010f\u0111\7Y\2\2\u0110\u010d\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u010f"+ 15993 "\3\2\2\2\u0111\13\3\2\2\2\u0112\u011d\5\6\4\2\u0113\u011c\5\4\3\2\u0114"+ 15994 "\u0115\6\7\3\2\u0115\u011c\7\3\2\2\u0116\u011c\5\u0094K\2\u0117\u011c"+ 15995 "\7\5\2\2\u0118\u011c\7\b\2\2\u0119\u011c\5\u0096L\2\u011a\u011c\5\u0092"+ 15996 "J\2\u011b\u0113\3\2\2\2\u011b\u0114\3\2\2\2\u011b\u0116\3\2\2\2\u011b"+ 15997 "\u0117\3\2\2\2\u011b\u0118\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2"+ 15998 "\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+ 15999 "\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\5\b\5\2\u0121\u0133\3\2"+ 16000 "\2\2\u0122\u012d\5\6\4\2\u0123\u012c\5\4\3\2\u0124\u0125\6\7\4\2\u0125"+ 16001 "\u012c\7\3\2\2\u0126\u012c\5\u0094K\2\u0127\u012c\7\5\2\2\u0128\u012c"+ 16002 "\7\b\2\2\u0129\u012c\5\u0096L\2\u012a\u012c\5\u0092J\2\u012b\u0123\3\2"+ 16003 "\2\2\u012b\u0124\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012b"+ 16004 "\u0128\3\2\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f\3\2"+ 16005 "\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0130\3\2\2\2\u012f"+ 16006 "\u012d\3\2\2\2\u0130\u0131\b\7\1\2\u0131\u0133\3\2\2\2\u0132\u0112\3\2"+ 16007 "\2\2\u0132\u0122\3\2\2\2\u0133\r\3\2\2\2\u0134\u0135\7\7\2\2\u0135\u013c"+ 16008 "\7=\2\2\u0136\u013b\5\n\6\2\u0137\u013b\7\b\2\2\u0138\u013b\7\3\2\2\u0139"+ 16009 "\u013b\7\6\2\2\u013a\u0136\3\2\2\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2"+ 16010 "\2\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+ 16011 "\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0140\79"+ 16012 "\2\2\u0140\17\3\2\2\2\u0141\u0142\7\7\2\2\u0142\u0143\7;\2\2\u0143\u0147"+ 16013 "\7=\2\2\u0144\u0146\t\2\2\2\u0145\u0144\3\2\2\2\u0146\u0149\3\2\2\2\u0147"+ 16014 "\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2\u0149\u0147\3\2"+ 16015 "\2\2\u014a\u014b\79\2\2\u014b\21\3\2\2\2\u014c\u0174\5\16\b\2\u014d\u0173"+ 16016 "\5\f\7\2\u014e\u0173\5j\66\2\u014f\u0173\5\30\r\2\u0150\u0173\5\36\20"+ 16017 "\2\u0151\u0173\5$\23\2\u0152\u0173\5*\26\2\u0153\u0173\5\60\31\2\u0154"+ 16018 "\u0173\5\66\34\2\u0155\u0173\5<\37\2\u0156\u0173\5B\"\2\u0157\u0173\5"+ 16019 "H%\2\u0158\u0173\5N(\2\u0159\u0173\5T+\2\u015a\u0173\5Z.\2\u015b\u0173"+ 16020 "\5f\64\2\u015c\u0173\5`\61\2\u015d\u0173\5\24\13\2\u015e\u0173\5\32\16"+ 16021 "\2\u015f\u0173\5 \21\2\u0160\u0173\5&\24\2\u0161\u0173\5,\27\2\u0162\u0173"+ 16022 "\5\62\32\2\u0163\u0173\58\35\2\u0164\u0173\5> \2\u0165\u0173\5D#\2\u0166"+ 16023 "\u0173\5J&\2\u0167\u0173\5P)\2\u0168\u0173\5V,\2\u0169\u0173\5b\62\2\u016a"+ 16024 "\u0173\5\\/\2\u016b\u016c\6\n\5\2\u016c\u0173\7\3\2\2\u016d\u0173\5\u0094"+ 16025 "K\2\u016e\u0173\7\5\2\2\u016f\u0173\7\b\2\2\u0170\u0173\5\u0096L\2\u0171"+ 16026 "\u0173\5\u0092J\2\u0172\u014d\3\2\2\2\u0172\u014e\3\2\2\2\u0172\u014f"+ 16027 "\3\2\2\2\u0172\u0150\3\2\2\2\u0172\u0151\3\2\2\2\u0172\u0152\3\2\2\2\u0172"+ 16028 "\u0153\3\2\2\2\u0172\u0154\3\2\2\2\u0172\u0155\3\2\2\2\u0172\u0156\3\2"+ 16029 "\2\2\u0172\u0157\3\2\2\2\u0172\u0158\3\2\2\2\u0172\u0159\3\2\2\2\u0172"+ 16030 "\u015a\3\2\2\2\u0172\u015b\3\2\2\2\u0172\u015c\3\2\2\2\u0172\u015d\3\2"+ 16031 "\2\2\u0172\u015e\3\2\2\2\u0172\u015f\3\2\2\2\u0172\u0160\3\2\2\2\u0172"+ 16032 "\u0161\3\2\2\2\u0172\u0162\3\2\2\2\u0172\u0163\3\2\2\2\u0172\u0164\3\2"+ 16033 "\2\2\u0172\u0165\3\2\2\2\u0172\u0166\3\2\2\2\u0172\u0167\3\2\2\2\u0172"+ 16034 "\u0168\3\2\2\2\u0172\u0169\3\2\2\2\u0172\u016a\3\2\2\2\u0172\u016b\3\2"+ 16035 "\2\2\u0172\u016d\3\2\2\2\u0172\u016e\3\2\2\2\u0172\u016f\3\2\2\2\u0172"+ 16036 "\u0170\3\2\2\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2"+ 16037 "\2\2\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177"+ 16038 "\u0178\5\20\t\2\u0178\23\3\2\2\2\u0179\u017a\7\7\2\2\u017a\u0181\7>\2"+ 16039 "\2\u017b\u0180\5\n\6\2\u017c\u0180\7\b\2\2\u017d\u0180\7\3\2\2\u017e\u0180"+ 16040 "\7\6\2\2\u017f\u017b\3\2\2\2\u017f\u017c\3\2\2\2\u017f\u017d\3\2\2\2\u017f"+ 16041 "\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+ 16042 "\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\79\2\2\u0185"+ 16043 "\25\3\2\2\2\u0186\u0187\7\7\2\2\u0187\u0188\7;\2\2\u0188\u018c\7>\2\2"+ 16044 "\u0189\u018b\t\2\2\2\u018a\u0189\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a"+ 16045 "\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f"+ 16046 "\u0190\79\2\2\u0190\27\3\2\2\2\u0191\u01b9\5\24\13\2\u0192\u01b8\5\f\7"+ 16047 "\2\u0193\u01b8\5j\66\2\u0194\u01b8\5\22\n\2\u0195\u01b8\5\36\20\2\u0196"+ 16048 "\u01b8\5$\23\2\u0197\u01b8\5*\26\2\u0198\u01b8\5\60\31\2\u0199\u01b8\5"+ 16049 "\66\34\2\u019a\u01b8\5<\37\2\u019b\u01b8\5B\"\2\u019c\u01b8\5H%\2\u019d"+ 16050 "\u01b8\5N(\2\u019e\u01b8\5T+\2\u019f\u01b8\5Z.\2\u01a0\u01b8\5f\64\2\u01a1"+ 16051 "\u01b8\5`\61\2\u01a2\u01b8\5\16\b\2\u01a3\u01b8\5\32\16\2\u01a4\u01b8"+ 16052 "\5 \21\2\u01a5\u01b8\5&\24\2\u01a6\u01b8\5,\27\2\u01a7\u01b8\5\62\32\2"+ 16053 "\u01a8\u01b8\58\35\2\u01a9\u01b8\5> \2\u01aa\u01b8\5D#\2\u01ab\u01b8\5"+ 16054 "J&\2\u01ac\u01b8\5P)\2\u01ad\u01b8\5V,\2\u01ae\u01b8\5b\62\2\u01af\u01b8"+ 16055 "\5\\/\2\u01b0\u01b1\6\r\6\2\u01b1\u01b8\7\3\2\2\u01b2\u01b8\5\u0094K\2"+ 16056 "\u01b3\u01b8\7\5\2\2\u01b4\u01b8\7\b\2\2\u01b5\u01b8\5\u0096L\2\u01b6"+ 16057 "\u01b8\5\u0092J\2\u01b7\u0192\3\2\2\2\u01b7\u0193\3\2\2\2\u01b7\u0194"+ 16058 "\3\2\2\2\u01b7\u0195\3\2\2\2\u01b7\u0196\3\2\2\2\u01b7\u0197\3\2\2\2\u01b7"+ 16059 "\u0198\3\2\2\2\u01b7\u0199\3\2\2\2\u01b7\u019a\3\2\2\2\u01b7\u019b\3\2"+ 16060 "\2\2\u01b7\u019c\3\2\2\2\u01b7\u019d\3\2\2\2\u01b7\u019e\3\2\2\2\u01b7"+ 16061 "\u019f\3\2\2\2\u01b7\u01a0\3\2\2\2\u01b7\u01a1\3\2\2\2\u01b7\u01a2\3\2"+ 16062 "\2\2\u01b7\u01a3\3\2\2\2\u01b7\u01a4\3\2\2\2\u01b7\u01a5\3\2\2\2\u01b7"+ 16063 "\u01a6\3\2\2\2\u01b7\u01a7\3\2\2\2\u01b7\u01a8\3\2\2\2\u01b7\u01a9\3\2"+ 16064 "\2\2\u01b7\u01aa\3\2\2\2\u01b7\u01ab\3\2\2\2\u01b7\u01ac\3\2\2\2\u01b7"+ 16065 "\u01ad\3\2\2\2\u01b7\u01ae\3\2\2\2\u01b7\u01af\3\2\2\2\u01b7\u01b0\3\2"+ 16066 "\2\2\u01b7\u01b2\3\2\2\2\u01b7\u01b3\3\2\2\2\u01b7\u01b4\3\2\2\2\u01b7"+ 16067 "\u01b5\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2"+ 16068 "\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc"+ 16069 "\u01bd\5\26\f\2\u01bd\31\3\2\2\2\u01be\u01bf\7\7\2\2\u01bf\u01c6\7?\2"+ 16070 "\2\u01c0\u01c5\5\n\6\2\u01c1\u01c5\7\b\2\2\u01c2\u01c5\7\3\2\2\u01c3\u01c5"+ 16071 "\7\6\2\2\u01c4\u01c0\3\2\2\2\u01c4\u01c1\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c4"+ 16072 "\u01c3\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2"+ 16073 "\2\2\u01c7\u01c9\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\79\2\2\u01ca"+ 16074 "\33\3\2\2\2\u01cb\u01cc\7\7\2\2\u01cc\u01cd\7;\2\2\u01cd\u01d1\7?\2\2"+ 16075 "\u01ce\u01d0\t\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+ 16076 "\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d4\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+ 16077 "\u01d5\79\2\2\u01d5\35\3\2\2\2\u01d6\u01fe\5\32\16\2\u01d7\u01fd\5\f\7"+ 16078 "\2\u01d8\u01fd\5j\66\2\u01d9\u01fd\5\22\n\2\u01da\u01fd\5\30\r\2\u01db"+ 16079 "\u01fd\5$\23\2\u01dc\u01fd\5*\26\2\u01dd\u01fd\5\60\31\2\u01de\u01fd\5"+ 16080 "\66\34\2\u01df\u01fd\5<\37\2\u01e0\u01fd\5B\"\2\u01e1\u01fd\5H%\2\u01e2"+ 16081 "\u01fd\5N(\2\u01e3\u01fd\5T+\2\u01e4\u01fd\5Z.\2\u01e5\u01fd\5f\64\2\u01e6"+ 16082 "\u01fd\5`\61\2\u01e7\u01fd\5\16\b\2\u01e8\u01fd\5\24\13\2\u01e9\u01fd"+ 16083 "\5 \21\2\u01ea\u01fd\5&\24\2\u01eb\u01fd\5,\27\2\u01ec\u01fd\5\62\32\2"+ 16084 "\u01ed\u01fd\58\35\2\u01ee\u01fd\5> \2\u01ef\u01fd\5D#\2\u01f0\u01fd\5"+ 16085 "J&\2\u01f1\u01fd\5P)\2\u01f2\u01fd\5V,\2\u01f3\u01fd\5b\62\2\u01f4\u01fd"+ 16086 "\5\\/\2\u01f5\u01f6\6\20\7\2\u01f6\u01fd\7\3\2\2\u01f7\u01fd\5\u0094K"+ 16087 "\2\u01f8\u01fd\7\5\2\2\u01f9\u01fd\7\b\2\2\u01fa\u01fd\5\u0096L\2\u01fb"+ 16088 "\u01fd\5\u0092J\2\u01fc\u01d7\3\2\2\2\u01fc\u01d8\3\2\2\2\u01fc\u01d9"+ 16089 "\3\2\2\2\u01fc\u01da\3\2\2\2\u01fc\u01db\3\2\2\2\u01fc\u01dc\3\2\2\2\u01fc"+ 16090 "\u01dd\3\2\2\2\u01fc\u01de\3\2\2\2\u01fc\u01df\3\2\2\2\u01fc\u01e0\3\2"+ 16091 "\2\2\u01fc\u01e1\3\2\2\2\u01fc\u01e2\3\2\2\2\u01fc\u01e3\3\2\2\2\u01fc"+ 16092 "\u01e4\3\2\2\2\u01fc\u01e5\3\2\2\2\u01fc\u01e6\3\2\2\2\u01fc\u01e7\3\2"+ 16093 "\2\2\u01fc\u01e8\3\2\2\2\u01fc\u01e9\3\2\2\2\u01fc\u01ea\3\2\2\2\u01fc"+ 16094 "\u01eb\3\2\2\2\u01fc\u01ec\3\2\2\2\u01fc\u01ed\3\2\2\2\u01fc\u01ee\3\2"+ 16095 "\2\2\u01fc\u01ef\3\2\2\2\u01fc\u01f0\3\2\2\2\u01fc\u01f1\3\2\2\2\u01fc"+ 16096 "\u01f2\3\2\2\2\u01fc\u01f3\3\2\2\2\u01fc\u01f4\3\2\2\2\u01fc\u01f5\3\2"+ 16097 "\2\2\u01fc\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc"+ 16098 "\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2"+ 16099 "\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201\3\2\2\2\u0200\u01fe\3\2\2\2\u0201"+ 16100 "\u0202\5\34\17\2\u0202\37\3\2\2\2\u0203\u0204\7\7\2\2\u0204\u020b\7@\2"+ 16101 "\2\u0205\u020a\5\n\6\2\u0206\u020a\7\b\2\2\u0207\u020a\7\3\2\2\u0208\u020a"+ 16102 "\7\6\2\2\u0209\u0205\3\2\2\2\u0209\u0206\3\2\2\2\u0209\u0207\3\2\2\2\u0209"+ 16103 "\u0208\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2"+ 16104 "\2\2\u020c\u020e\3\2\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f"+ 16105 "!\3\2\2\2\u0210\u0211\7\7\2\2\u0211\u0212\7;\2\2\u0212\u0216\7@\2\2\u0213"+ 16106 "\u0215\t\2\2\2\u0214\u0213\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2"+ 16107 "\2\2\u0216\u0217\3\2\2\2\u0217\u0219\3\2\2\2\u0218\u0216\3\2\2\2\u0219"+ 16108 "\u021a\79\2\2\u021a#\3\2\2\2\u021b\u0243\5 \21\2\u021c\u0242\5\f\7\2\u021d"+ 16109 "\u0242\5j\66\2\u021e\u0242\5\22\n\2\u021f\u0242\5\30\r\2\u0220\u0242\5"+ 16110 "\36\20\2\u0221\u0242\5*\26\2\u0222\u0242\5\60\31\2\u0223\u0242\5\66\34"+ 16111 "\2\u0224\u0242\5<\37\2\u0225\u0242\5B\"\2\u0226\u0242\5H%\2\u0227\u0242"+ 16112 "\5N(\2\u0228\u0242\5T+\2\u0229\u0242\5Z.\2\u022a\u0242\5f\64\2\u022b\u0242"+ 16113 "\5`\61\2\u022c\u0242\5\16\b\2\u022d\u0242\5\24\13\2\u022e\u0242\5 \21"+ 16114 "\2\u022f\u0242\5&\24\2\u0230\u0242\5,\27\2\u0231\u0242\5\62\32\2\u0232"+ 16115 "\u0242\58\35\2\u0233\u0242\5> \2\u0234\u0242\5D#\2\u0235\u0242\5J&\2\u0236"+ 16116 "\u0242\5P)\2\u0237\u0242\5V,\2\u0238\u0242\5b\62\2\u0239\u0242\5\\/\2"+ 16117 "\u023a\u023b\6\23\b\2\u023b\u0242\7\3\2\2\u023c\u0242\5\u0094K\2\u023d"+ 16118 "\u0242\7\5\2\2\u023e\u0242\7\b\2\2\u023f\u0242\5\u0096L\2\u0240\u0242"+ 16119 "\5\u0092J\2\u0241\u021c\3\2\2\2\u0241\u021d\3\2\2\2\u0241\u021e\3\2\2"+ 16120 "\2\u0241\u021f\3\2\2\2\u0241\u0220\3\2\2\2\u0241\u0221\3\2\2\2\u0241\u0222"+ 16121 "\3\2\2\2\u0241\u0223\3\2\2\2\u0241\u0224\3\2\2\2\u0241\u0225\3\2\2\2\u0241"+ 16122 "\u0226\3\2\2\2\u0241\u0227\3\2\2\2\u0241\u0228\3\2\2\2\u0241\u0229\3\2"+ 16123 "\2\2\u0241\u022a\3\2\2\2\u0241\u022b\3\2\2\2\u0241\u022c\3\2\2\2\u0241"+ 16124 "\u022d\3\2\2\2\u0241\u022e\3\2\2\2\u0241\u022f\3\2\2\2\u0241\u0230\3\2"+ 16125 "\2\2\u0241\u0231\3\2\2\2\u0241\u0232\3\2\2\2\u0241\u0233\3\2\2\2\u0241"+ 16126 "\u0234\3\2\2\2\u0241\u0235\3\2\2\2\u0241\u0236\3\2\2\2\u0241\u0237\3\2"+ 16127 "\2\2\u0241\u0238\3\2\2\2\u0241\u0239\3\2\2\2\u0241\u023a\3\2\2\2\u0241"+ 16128 "\u023c\3\2\2\2\u0241\u023d\3\2\2\2\u0241\u023e\3\2\2\2\u0241\u023f\3\2"+ 16129 "\2\2\u0241\u0240\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243"+ 16130 "\u0244\3\2\2\2\u0244\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\5\""+ 16131 "\22\2\u0247%\3\2\2\2\u0248\u0249\7\7\2\2\u0249\u0250\7A\2\2\u024a\u024f"+ 16132 "\5\n\6\2\u024b\u024f\7\b\2\2\u024c\u024f\7\3\2\2\u024d\u024f\7\6\2\2\u024e"+ 16133 "\u024a\3\2\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2"+ 16134 "\2\2\u024f\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251"+ 16135 "\u0253\3\2\2\2\u0252\u0250\3\2\2\2\u0253\u0254\79\2\2\u0254\'\3\2\2\2"+ 16136 "\u0255\u0256\7\7\2\2\u0256\u0257\7;\2\2\u0257\u025b\7A\2\2\u0258\u025a"+ 16137 "\t\2\2\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b"+ 16138 "\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f\79"+ 16139 "\2\2\u025f)\3\2\2\2\u0260\u0288\5&\24\2\u0261\u0287\5\f\7\2\u0262\u0287"+ 16140 "\5j\66\2\u0263\u0287\5\22\n\2\u0264\u0287\5\30\r\2\u0265\u0287\5\36\20"+ 16141 "\2\u0266\u0287\5$\23\2\u0267\u0287\5\60\31\2\u0268\u0287\5\66\34\2\u0269"+ 16142 "\u0287\5<\37\2\u026a\u0287\5B\"\2\u026b\u0287\5H%\2\u026c\u0287\5N(\2"+ 16143 "\u026d\u0287\5T+\2\u026e\u0287\5Z.\2\u026f\u0287\5f\64\2\u0270\u0287\5"+ 16144 "`\61\2\u0271\u0287\5\16\b\2\u0272\u0287\5\24\13\2\u0273\u0287\5\32\16"+ 16145 "\2\u0274\u0287\5 \21\2\u0275\u0287\5,\27\2\u0276\u0287\5\62\32\2\u0277"+ 16146 "\u0287\58\35\2\u0278\u0287\5> \2\u0279\u0287\5D#\2\u027a\u0287\5J&\2\u027b"+ 16147 "\u0287\5P)\2\u027c\u0287\5V,\2\u027d\u0287\5b\62\2\u027e\u0287\5\\/\2"+ 16148 "\u027f\u0280\6\26\t\2\u0280\u0287\7\3\2\2\u0281\u0287\5\u0094K\2\u0282"+ 16149 "\u0287\7\5\2\2\u0283\u0287\7\b\2\2\u0284\u0287\5\u0096L\2\u0285\u0287"+ 16150 "\5\u0092J\2\u0286\u0261\3\2\2\2\u0286\u0262\3\2\2\2\u0286\u0263\3\2\2"+ 16151 "\2\u0286\u0264\3\2\2\2\u0286\u0265\3\2\2\2\u0286\u0266\3\2\2\2\u0286\u0267"+ 16152 "\3\2\2\2\u0286\u0268\3\2\2\2\u0286\u0269\3\2\2\2\u0286\u026a\3\2\2\2\u0286"+ 16153 "\u026b\3\2\2\2\u0286\u026c\3\2\2\2\u0286\u026d\3\2\2\2\u0286\u026e\3\2"+ 16154 "\2\2\u0286\u026f\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0271\3\2\2\2\u0286"+ 16155 "\u0272\3\2\2\2\u0286\u0273\3\2\2\2\u0286\u0274\3\2\2\2\u0286\u0275\3\2"+ 16156 "\2\2\u0286\u0276\3\2\2\2\u0286\u0277\3\2\2\2\u0286\u0278\3\2\2\2\u0286"+ 16157 "\u0279\3\2\2\2\u0286\u027a\3\2\2\2\u0286\u027b\3\2\2\2\u0286\u027c\3\2"+ 16158 "\2\2\u0286\u027d\3\2\2\2\u0286\u027e\3\2\2\2\u0286\u027f\3\2\2\2\u0286"+ 16159 "\u0281\3\2\2\2\u0286\u0282\3\2\2\2\u0286\u0283\3\2\2\2\u0286\u0284\3\2"+ 16160 "\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+ 16161 "\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\5("+ 16162 "\25\2\u028c+\3\2\2\2\u028d\u028e\7\7\2\2\u028e\u0295\7B\2\2\u028f\u0294"+ 16163 "\5\n\6\2\u0290\u0294\7\b\2\2\u0291\u0294\7\3\2\2\u0292\u0294\7\6\2\2\u0293"+ 16164 "\u028f\3\2\2\2\u0293\u0290\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0292\3\2"+ 16165 "\2\2\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296"+ 16166 "\u0298\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0299\79\2\2\u0299-\3\2\2\2\u029a"+ 16167 "\u029b\7\7\2\2\u029b\u029c\7;\2\2\u029c\u02a0\7B\2\2\u029d\u029f\t\2\2"+ 16168 "\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e\3\2\2\2\u02a0\u02a1"+ 16169 "\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a3\u02a4\79\2\2\u02a4"+ 16170 "/\3\2\2\2\u02a5\u02cd\5,\27\2\u02a6\u02cc\5\f\7\2\u02a7\u02cc\5j\66\2"+ 16171 "\u02a8\u02cc\5\22\n\2\u02a9\u02cc\5\30\r\2\u02aa\u02cc\5\36\20\2\u02ab"+ 16172 "\u02cc\5$\23\2\u02ac\u02cc\5*\26\2\u02ad\u02cc\5\66\34\2\u02ae\u02cc\5"+ 16173 "<\37\2\u02af\u02cc\5B\"\2\u02b0\u02cc\5H%\2\u02b1\u02cc\5N(\2\u02b2\u02cc"+ 16174 "\5T+\2\u02b3\u02cc\5Z.\2\u02b4\u02cc\5f\64\2\u02b5\u02cc\5`\61\2\u02b6"+ 16175 "\u02cc\5\16\b\2\u02b7\u02cc\5\24\13\2\u02b8\u02cc\5\32\16\2\u02b9\u02cc"+ 16176 "\5 \21\2\u02ba\u02cc\5&\24\2\u02bb\u02cc\5\62\32\2\u02bc\u02cc\58\35\2"+ 16177 "\u02bd\u02cc\5> \2\u02be\u02cc\5D#\2\u02bf\u02cc\5J&\2\u02c0\u02cc\5P"+ 16178 ")\2\u02c1\u02cc\5V,\2\u02c2\u02cc\5b\62\2\u02c3\u02cc\5\\/\2\u02c4\u02c5"+ 16179 "\6\31\n\2\u02c5\u02cc\7\3\2\2\u02c6\u02cc\5\u0094K\2\u02c7\u02cc\7\5\2"+ 16180 "\2\u02c8\u02cc\7\b\2\2\u02c9\u02cc\5\u0096L\2\u02ca\u02cc\5\u0092J\2\u02cb"+ 16181 "\u02a6\3\2\2\2\u02cb\u02a7\3\2\2\2\u02cb\u02a8\3\2\2\2\u02cb\u02a9\3\2"+ 16182 "\2\2\u02cb\u02aa\3\2\2\2\u02cb\u02ab\3\2\2\2\u02cb\u02ac\3\2\2\2\u02cb"+ 16183 "\u02ad\3\2\2\2\u02cb\u02ae\3\2\2\2\u02cb\u02af\3\2\2\2\u02cb\u02b0\3\2"+ 16184 "\2\2\u02cb\u02b1\3\2\2\2\u02cb\u02b2\3\2\2\2\u02cb\u02b3\3\2\2\2\u02cb"+ 16185 "\u02b4\3\2\2\2\u02cb\u02b5\3\2\2\2\u02cb\u02b6\3\2\2\2\u02cb\u02b7\3\2"+ 16186 "\2\2\u02cb\u02b8\3\2\2\2\u02cb\u02b9\3\2\2\2\u02cb\u02ba\3\2\2\2\u02cb"+ 16187 "\u02bb\3\2\2\2\u02cb\u02bc\3\2\2\2\u02cb\u02bd\3\2\2\2\u02cb\u02be\3\2"+ 16188 "\2\2\u02cb\u02bf\3\2\2\2\u02cb\u02c0\3\2\2\2\u02cb\u02c1\3\2\2\2\u02cb"+ 16189 "\u02c2\3\2\2\2\u02cb\u02c3\3\2\2\2\u02cb\u02c4\3\2\2\2\u02cb\u02c6\3\2"+ 16190 "\2\2\u02cb\u02c7\3\2\2\2\u02cb\u02c8\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cb"+ 16191 "\u02ca\3\2\2\2\u02cc\u02cf\3\2\2\2\u02cd\u02cb\3\2\2\2\u02cd\u02ce\3\2"+ 16192 "\2\2\u02ce\u02d0\3\2\2\2\u02cf\u02cd\3\2\2\2\u02d0\u02d1\5.\30\2\u02d1"+ 16193 "\61\3\2\2\2\u02d2\u02d3\7\7\2\2\u02d3\u02da\7C\2\2\u02d4\u02d9\5\n\6\2"+ 16194 "\u02d5\u02d9\7\b\2\2\u02d6\u02d9\7\3\2\2\u02d7\u02d9\7\6\2\2\u02d8\u02d4"+ 16195 "\3\2\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d8\u02d7\3\2\2\2\u02d9"+ 16196 "\u02dc\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2"+ 16197 "\2\2\u02dc\u02da\3\2\2\2\u02dd\u02de\79\2\2\u02de\63\3\2\2\2\u02df\u02e0"+ 16198 "\7\7\2\2\u02e0\u02e1\7;\2\2\u02e1\u02e5\7C\2\2\u02e2\u02e4\t\2\2\2\u02e3"+ 16199 "\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2"+ 16200 "\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\79\2\2\u02e9"+ 16201 "\65\3\2\2\2\u02ea\u0312\5\62\32\2\u02eb\u0311\5\f\7\2\u02ec\u0311\5j\66"+ 16202 "\2\u02ed\u0311\5\22\n\2\u02ee\u0311\5\30\r\2\u02ef\u0311\5\36\20\2\u02f0"+ 16203 "\u0311\5$\23\2\u02f1\u0311\5*\26\2\u02f2\u0311\5\60\31\2\u02f3\u0311\5"+ 16204 "<\37\2\u02f4\u0311\5B\"\2\u02f5\u0311\5H%\2\u02f6\u0311\5N(\2\u02f7\u0311"+ 16205 "\5T+\2\u02f8\u0311\5Z.\2\u02f9\u0311\5f\64\2\u02fa\u0311\5`\61\2\u02fb"+ 16206 "\u0311\5\16\b\2\u02fc\u0311\5\24\13\2\u02fd\u0311\5\32\16\2\u02fe\u0311"+ 16207 "\5 \21\2\u02ff\u0311\5&\24\2\u0300\u0311\5,\27\2\u0301\u0311\58\35\2\u0302"+ 16208 "\u0311\5> \2\u0303\u0311\5D#\2\u0304\u0311\5J&\2\u0305\u0311\5P)\2\u0306"+ 16209 "\u0311\5V,\2\u0307\u0311\5b\62\2\u0308\u0311\5\\/\2\u0309\u030a\6\34\13"+ 16210 "\2\u030a\u0311\7\3\2\2\u030b\u0311\5\u0094K\2\u030c\u0311\7\5\2\2\u030d"+ 16211 "\u0311\7\b\2\2\u030e\u0311\5\u0096L\2\u030f\u0311\5\u0092J\2\u0310\u02eb"+ 16212 "\3\2\2\2\u0310\u02ec\3\2\2\2\u0310\u02ed\3\2\2\2\u0310\u02ee\3\2\2\2\u0310"+ 16213 "\u02ef\3\2\2\2\u0310\u02f0\3\2\2\2\u0310\u02f1\3\2\2\2\u0310\u02f2\3\2"+ 16214 "\2\2\u0310\u02f3\3\2\2\2\u0310\u02f4\3\2\2\2\u0310\u02f5\3\2\2\2\u0310"+ 16215 "\u02f6\3\2\2\2\u0310\u02f7\3\2\2\2\u0310\u02f8\3\2\2\2\u0310\u02f9\3\2"+ 16216 "\2\2\u0310\u02fa\3\2\2\2\u0310\u02fb\3\2\2\2\u0310\u02fc\3\2\2\2\u0310"+ 16217 "\u02fd\3\2\2\2\u0310\u02fe\3\2\2\2\u0310\u02ff\3\2\2\2\u0310\u0300\3\2"+ 16218 "\2\2\u0310\u0301\3\2\2\2\u0310\u0302\3\2\2\2\u0310\u0303\3\2\2\2\u0310"+ 16219 "\u0304\3\2\2\2\u0310\u0305\3\2\2\2\u0310\u0306\3\2\2\2\u0310\u0307\3\2"+ 16220 "\2\2\u0310\u0308\3\2\2\2\u0310\u0309\3\2\2\2\u0310\u030b\3\2\2\2\u0310"+ 16221 "\u030c\3\2\2\2\u0310\u030d\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u030f\3\2"+ 16222 "\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+ 16223 "\u0315\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0316\5\64\33\2\u0316\67\3\2"+ 16224 "\2\2\u0317\u0318\7\7\2\2\u0318\u031f\7D\2\2\u0319\u031e\5\n\6\2\u031a"+ 16225 "\u031e\7\b\2\2\u031b\u031e\7\3\2\2\u031c\u031e\7\6\2\2\u031d\u0319\3\2"+ 16226 "\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031c\3\2\2\2\u031e"+ 16227 "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2"+ 16228 "\2\2\u0321\u031f\3\2\2\2\u0322\u0323\79\2\2\u03239\3\2\2\2\u0324\u0325"+ 16229 "\7\7\2\2\u0325\u0326\7;\2\2\u0326\u032a\7D\2\2\u0327\u0329\t\2\2\2\u0328"+ 16230 "\u0327\3\2\2\2\u0329\u032c\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u032b\3\2"+ 16231 "\2\2\u032b\u032d\3\2\2\2\u032c\u032a\3\2\2\2\u032d\u032e\79\2\2\u032e"+ 16232 ";\3\2\2\2\u032f\u0357\58\35\2\u0330\u0356\5\f\7\2\u0331\u0356\5j\66\2"+ 16233 "\u0332\u0356\5\22\n\2\u0333\u0356\5\30\r\2\u0334\u0356\5\36\20\2\u0335"+ 16234 "\u0356\5$\23\2\u0336\u0356\5*\26\2\u0337\u0356\5\60\31\2\u0338\u0356\5"+ 16235 "\66\34\2\u0339\u0356\5B\"\2\u033a\u0356\5H%\2\u033b\u0356\5N(\2\u033c"+ 16236 "\u0356\5T+\2\u033d\u0356\5Z.\2\u033e\u0356\5f\64\2\u033f\u0356\5`\61\2"+ 16237 "\u0340\u0356\5\16\b\2\u0341\u0356\5\24\13\2\u0342\u0356\5\32\16\2\u0343"+ 16238 "\u0356\5 \21\2\u0344\u0356\5&\24\2\u0345\u0356\5,\27\2\u0346\u0356\5\62"+ 16239 "\32\2\u0347\u0356\5> \2\u0348\u0356\5D#\2\u0349\u0356\5J&\2\u034a\u0356"+ 16240 "\5P)\2\u034b\u0356\5V,\2\u034c\u0356\5b\62\2\u034d\u0356\5\\/\2\u034e"+ 16241 "\u034f\6\37\f\2\u034f\u0356\7\3\2\2\u0350\u0356\5\u0094K\2\u0351\u0356"+ 16242 "\7\5\2\2\u0352\u0356\7\b\2\2\u0353\u0356\5\u0096L\2\u0354\u0356\5\u0092"+ 16243 "J\2\u0355\u0330\3\2\2\2\u0355\u0331\3\2\2\2\u0355\u0332\3\2\2\2\u0355"+ 16244 "\u0333\3\2\2\2\u0355\u0334\3\2\2\2\u0355\u0335\3\2\2\2\u0355\u0336\3\2"+ 16245 "\2\2\u0355\u0337\3\2\2\2\u0355\u0338\3\2\2\2\u0355\u0339\3\2\2\2\u0355"+ 16246 "\u033a\3\2\2\2\u0355\u033b\3\2\2\2\u0355\u033c\3\2\2\2\u0355\u033d\3\2"+ 16247 "\2\2\u0355\u033e\3\2\2\2\u0355\u033f\3\2\2\2\u0355\u0340\3\2\2\2\u0355"+ 16248 "\u0341\3\2\2\2\u0355\u0342\3\2\2\2\u0355\u0343\3\2\2\2\u0355\u0344\3\2"+ 16249 "\2\2\u0355\u0345\3\2\2\2\u0355\u0346\3\2\2\2\u0355\u0347\3\2\2\2\u0355"+ 16250 "\u0348\3\2\2\2\u0355\u0349\3\2\2\2\u0355\u034a\3\2\2\2\u0355\u034b\3\2"+ 16251 "\2\2\u0355\u034c\3\2\2\2\u0355\u034d\3\2\2\2\u0355\u034e\3\2\2\2\u0355"+ 16252 "\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0355\u0352\3\2\2\2\u0355\u0353\3\2"+ 16253 "\2\2\u0355\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357"+ 16254 "\u0358\3\2\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\5:"+ 16255 "\36\2\u035b=\3\2\2\2\u035c\u035d\7\7\2\2\u035d\u0364\7E\2\2\u035e\u0363"+ 16256 "\5\n\6\2\u035f\u0363\7\b\2\2\u0360\u0363\7\3\2\2\u0361\u0363\7\6\2\2\u0362"+ 16257 "\u035e\3\2\2\2\u0362\u035f\3\2\2\2\u0362\u0360\3\2\2\2\u0362\u0361\3\2"+ 16258 "\2\2\u0363\u0366\3\2\2\2\u0364\u0362\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+ 16259 "\u0367\3\2\2\2\u0366\u0364\3\2\2\2\u0367\u0368\79\2\2\u0368?\3\2\2\2\u0369"+ 16260 "\u036a\7\7\2\2\u036a\u036b\7;\2\2\u036b\u036f\7E\2\2\u036c\u036e\t\2\2"+ 16261 "\2\u036d\u036c\3\2\2\2\u036e\u0371\3\2\2\2\u036f\u036d\3\2\2\2\u036f\u0370"+ 16262 "\3\2\2\2\u0370\u0372\3\2\2\2\u0371\u036f\3\2\2\2\u0372\u0373\79\2\2\u0373"+ 16263 "A\3\2\2\2\u0374\u039c\5> \2\u0375\u039b\5\f\7\2\u0376\u039b\5j\66\2\u0377"+ 16264 "\u039b\5\22\n\2\u0378\u039b\5\30\r\2\u0379\u039b\5\36\20\2\u037a\u039b"+ 16265 "\5$\23\2\u037b\u039b\5*\26\2\u037c\u039b\5\60\31\2\u037d\u039b\5\66\34"+ 16266 "\2\u037e\u039b\5<\37\2\u037f\u039b\5H%\2\u0380\u039b\5N(\2\u0381\u039b"+ 16267 "\5T+\2\u0382\u039b\5Z.\2\u0383\u039b\5f\64\2\u0384\u039b\5`\61\2\u0385"+ 16268 "\u039b\5\16\b\2\u0386\u039b\5\24\13\2\u0387\u039b\5\32\16\2\u0388\u039b"+ 16269 "\5 \21\2\u0389\u039b\5&\24\2\u038a\u039b\5,\27\2\u038b\u039b\5\62\32\2"+ 16270 "\u038c\u039b\58\35\2\u038d\u039b\5D#\2\u038e\u039b\5J&\2\u038f\u039b\5"+ 16271 "P)\2\u0390\u039b\5V,\2\u0391\u039b\5b\62\2\u0392\u039b\5\\/\2\u0393\u0394"+ 16272 "\6\"\r\2\u0394\u039b\7\3\2\2\u0395\u039b\5\u0094K\2\u0396\u039b\7\5\2"+ 16273 "\2\u0397\u039b\7\b\2\2\u0398\u039b\5\u0096L\2\u0399\u039b\5\u0092J\2\u039a"+ 16274 "\u0375\3\2\2\2\u039a\u0376\3\2\2\2\u039a\u0377\3\2\2\2\u039a\u0378\3\2"+ 16275 "\2\2\u039a\u0379\3\2\2\2\u039a\u037a\3\2\2\2\u039a\u037b\3\2\2\2\u039a"+ 16276 "\u037c\3\2\2\2\u039a\u037d\3\2\2\2\u039a\u037e\3\2\2\2\u039a\u037f\3\2"+ 16277 "\2\2\u039a\u0380\3\2\2\2\u039a\u0381\3\2\2\2\u039a\u0382\3\2\2\2\u039a"+ 16278 "\u0383\3\2\2\2\u039a\u0384\3\2\2\2\u039a\u0385\3\2\2\2\u039a\u0386\3\2"+ 16279 "\2\2\u039a\u0387\3\2\2\2\u039a\u0388\3\2\2\2\u039a\u0389\3\2\2\2\u039a"+ 16280 "\u038a\3\2\2\2\u039a\u038b\3\2\2\2\u039a\u038c\3\2\2\2\u039a\u038d\3\2"+ 16281 "\2\2\u039a\u038e\3\2\2\2\u039a\u038f\3\2\2\2\u039a\u0390\3\2\2\2\u039a"+ 16282 "\u0391\3\2\2\2\u039a\u0392\3\2\2\2\u039a\u0393\3\2\2\2\u039a\u0395\3\2"+ 16283 "\2\2\u039a\u0396\3\2\2\2\u039a\u0397\3\2\2\2\u039a\u0398\3\2\2\2\u039a"+ 16284 "\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2"+ 16285 "\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a0\5@!\2\u03a0C"+ 16286 "\3\2\2\2\u03a1\u03a2\7\7\2\2\u03a2\u03a9\7F\2\2\u03a3\u03a8\5\n\6\2\u03a4"+ 16287 "\u03a8\7\b\2\2\u03a5\u03a8\7\3\2\2\u03a6\u03a8\7\6\2\2\u03a7\u03a3\3\2"+ 16288 "\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6\3\2\2\2\u03a8"+ 16289 "\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ac\3\2"+ 16290 "\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ad\79\2\2\u03adE\3\2\2\2\u03ae\u03af"+ 16291 "\7\7\2\2\u03af\u03b0\7;\2\2\u03b0\u03b4\7F\2\2\u03b1\u03b3\t\2\2\2\u03b2"+ 16292 "\u03b1\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2"+ 16293 "\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b8\79\2\2\u03b8"+ 16294 "G\3\2\2\2\u03b9\u03e1\5D#\2\u03ba\u03e0\5\f\7\2\u03bb\u03e0\5j\66\2\u03bc"+ 16295 "\u03e0\5\22\n\2\u03bd\u03e0\5\30\r\2\u03be\u03e0\5\36\20\2\u03bf\u03e0"+ 16296 "\5$\23\2\u03c0\u03e0\5*\26\2\u03c1\u03e0\5\60\31\2\u03c2\u03e0\5\66\34"+ 16297 "\2\u03c3\u03e0\5<\37\2\u03c4\u03e0\5B\"\2\u03c5\u03e0\5N(\2\u03c6\u03e0"+ 16298 "\5T+\2\u03c7\u03e0\5Z.\2\u03c8\u03e0\5f\64\2\u03c9\u03e0\5`\61\2\u03ca"+ 16299 "\u03e0\5\16\b\2\u03cb\u03e0\5\24\13\2\u03cc\u03e0\5\32\16\2\u03cd\u03e0"+ 16300 "\5 \21\2\u03ce\u03e0\5&\24\2\u03cf\u03e0\5,\27\2\u03d0\u03e0\5\62\32\2"+ 16301 "\u03d1\u03e0\58\35\2\u03d2\u03e0\5> \2\u03d3\u03e0\5J&\2\u03d4\u03e0\5"+ 16302 "P)\2\u03d5\u03e0\5V,\2\u03d6\u03e0\5b\62\2\u03d7\u03e0\5\\/\2\u03d8\u03d9"+ 16303 "\6%\16\2\u03d9\u03e0\7\3\2\2\u03da\u03e0\5\u0094K\2\u03db\u03e0\7\5\2"+ 16304 "\2\u03dc\u03e0\7\b\2\2\u03dd\u03e0\5\u0096L\2\u03de\u03e0\5\u0092J\2\u03df"+ 16305 "\u03ba\3\2\2\2\u03df\u03bb\3\2\2\2\u03df\u03bc\3\2\2\2\u03df\u03bd\3\2"+ 16306 "\2\2\u03df\u03be\3\2\2\2\u03df\u03bf\3\2\2\2\u03df\u03c0\3\2\2\2\u03df"+ 16307 "\u03c1\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03c3\3\2\2\2\u03df\u03c4\3\2"+ 16308 "\2\2\u03df\u03c5\3\2\2\2\u03df\u03c6\3\2\2\2\u03df\u03c7\3\2\2\2\u03df"+ 16309 "\u03c8\3\2\2\2\u03df\u03c9\3\2\2\2\u03df\u03ca\3\2\2\2\u03df\u03cb\3\2"+ 16310 "\2\2\u03df\u03cc\3\2\2\2\u03df\u03cd\3\2\2\2\u03df\u03ce\3\2\2\2\u03df"+ 16311 "\u03cf\3\2\2\2\u03df\u03d0\3\2\2\2\u03df\u03d1\3\2\2\2\u03df\u03d2\3\2"+ 16312 "\2\2\u03df\u03d3\3\2\2\2\u03df\u03d4\3\2\2\2\u03df\u03d5\3\2\2\2\u03df"+ 16313 "\u03d6\3\2\2\2\u03df\u03d7\3\2\2\2\u03df\u03d8\3\2\2\2\u03df\u03da\3\2"+ 16314 "\2\2\u03df\u03db\3\2\2\2\u03df\u03dc\3\2\2\2\u03df\u03dd\3\2\2\2\u03df"+ 16315 "\u03de\3\2\2\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2"+ 16316 "\2\2\u03e2\u03e4\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5F$\2\u03e5I"+ 16317 "\3\2\2\2\u03e6\u03e7\7\7\2\2\u03e7\u03ee\7G\2\2\u03e8\u03ed\5\n\6\2\u03e9"+ 16318 "\u03ed\7\b\2\2\u03ea\u03ed\7\3\2\2\u03eb\u03ed\7\6\2\2\u03ec\u03e8\3\2"+ 16319 "\2\2\u03ec\u03e9\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed"+ 16320 "\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f1\3\2"+ 16321 "\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03f2\79\2\2\u03f2K\3\2\2\2\u03f3\u03f4"+ 16322 "\7\7\2\2\u03f4\u03f5\7;\2\2\u03f5\u03f9\7G\2\2\u03f6\u03f8\t\2\2\2\u03f7"+ 16323 "\u03f6\3\2\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2"+ 16324 "\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03fd\79\2\2\u03fd"+ 16325 "M\3\2\2\2\u03fe\u0426\5J&\2\u03ff\u0425\5\f\7\2\u0400\u0425\5j\66\2\u0401"+ 16326 "\u0425\5\22\n\2\u0402\u0425\5\30\r\2\u0403\u0425\5\36\20\2\u0404\u0425"+ 16327 "\5$\23\2\u0405\u0425\5*\26\2\u0406\u0425\5\60\31\2\u0407\u0425\5\66\34"+ 16328 "\2\u0408\u0425\5<\37\2\u0409\u0425\5B\"\2\u040a\u0425\5H%\2\u040b\u0425"+ 16329 "\5T+\2\u040c\u0425\5Z.\2\u040d\u0425\5f\64\2\u040e\u0425\5`\61\2\u040f"+ 16330 "\u0425\5\16\b\2\u0410\u0425\5\24\13\2\u0411\u0425\5\32\16\2\u0412\u0425"+ 16331 "\5 \21\2\u0413\u0425\5&\24\2\u0414\u0425\5,\27\2\u0415\u0425\5\62\32\2"+ 16332 "\u0416\u0425\58\35\2\u0417\u0425\5> \2\u0418\u0425\5D#\2\u0419\u0425\5"+ 16333 "P)\2\u041a\u0425\5V,\2\u041b\u0425\5b\62\2\u041c\u0425\5\\/\2\u041d\u041e"+ 16334 "\6(\17\2\u041e\u0425\7\3\2\2\u041f\u0425\5\u0094K\2\u0420\u0425\7\5\2"+ 16335 "\2\u0421\u0425\7\b\2\2\u0422\u0425\5\u0096L\2\u0423\u0425\5\u0092J\2\u0424"+ 16336 "\u03ff\3\2\2\2\u0424\u0400\3\2\2\2\u0424\u0401\3\2\2\2\u0424\u0402\3\2"+ 16337 "\2\2\u0424\u0403\3\2\2\2\u0424\u0404\3\2\2\2\u0424\u0405\3\2\2\2\u0424"+ 16338 "\u0406\3\2\2\2\u0424\u0407\3\2\2\2\u0424\u0408\3\2\2\2\u0424\u0409\3\2"+ 16339 "\2\2\u0424\u040a\3\2\2\2\u0424\u040b\3\2\2\2\u0424\u040c\3\2\2\2\u0424"+ 16340 "\u040d\3\2\2\2\u0424\u040e\3\2\2\2\u0424\u040f\3\2\2\2\u0424\u0410\3\2"+ 16341 "\2\2\u0424\u0411\3\2\2\2\u0424\u0412\3\2\2\2\u0424\u0413\3\2\2\2\u0424"+ 16342 "\u0414\3\2\2\2\u0424\u0415\3\2\2\2\u0424\u0416\3\2\2\2\u0424\u0417\3\2"+ 16343 "\2\2\u0424\u0418\3\2\2\2\u0424\u0419\3\2\2\2\u0424\u041a\3\2\2\2\u0424"+ 16344 "\u041b\3\2\2\2\u0424\u041c\3\2\2\2\u0424\u041d\3\2\2\2\u0424\u041f\3\2"+ 16345 "\2\2\u0424\u0420\3\2\2\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424"+ 16346 "\u0423\3\2\2\2\u0425\u0428\3\2\2\2\u0426\u0424\3\2\2\2\u0426\u0427\3\2"+ 16347 "\2\2\u0427\u0429\3\2\2\2\u0428\u0426\3\2\2\2\u0429\u042a\5L\'\2\u042a"+ 16348 "O\3\2\2\2\u042b\u042c\7\7\2\2\u042c\u0433\7H\2\2\u042d\u0432\5\n\6\2\u042e"+ 16349 "\u0432\7\b\2\2\u042f\u0432\7\3\2\2\u0430\u0432\7\6\2\2\u0431\u042d\3\2"+ 16350 "\2\2\u0431\u042e\3\2\2\2\u0431\u042f\3\2\2\2\u0431\u0430\3\2\2\2\u0432"+ 16351 "\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0436\3\2"+ 16352 "\2\2\u0435\u0433\3\2\2\2\u0436\u0437\79\2\2\u0437Q\3\2\2\2\u0438\u0439"+ 16353 "\7\7\2\2\u0439\u043a\7;\2\2\u043a\u043e\7H\2\2\u043b\u043d\t\2\2\2\u043c"+ 16354 "\u043b\3\2\2\2\u043d\u0440\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2"+ 16355 "\2\2\u043f\u0441\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0442\79\2\2\u0442"+ 16356 "S\3\2\2\2\u0443\u046b\5P)\2\u0444\u046a\5\f\7\2\u0445\u046a\5j\66\2\u0446"+ 16357 "\u046a\5\22\n\2\u0447\u046a\5\30\r\2\u0448\u046a\5\36\20\2\u0449\u046a"+ 16358 "\5$\23\2\u044a\u046a\5*\26\2\u044b\u046a\5\60\31\2\u044c\u046a\5\66\34"+ 16359 "\2\u044d\u046a\5<\37\2\u044e\u046a\5B\"\2\u044f\u046a\5H%\2\u0450\u046a"+ 16360 "\5N(\2\u0451\u046a\5Z.\2\u0452\u046a\5f\64\2\u0453\u046a\5`\61\2\u0454"+ 16361 "\u046a\5\16\b\2\u0455\u046a\5\24\13\2\u0456\u046a\5\32\16\2\u0457\u046a"+ 16362 "\5 \21\2\u0458\u046a\5&\24\2\u0459\u046a\5,\27\2\u045a\u046a\5\62\32\2"+ 16363 "\u045b\u046a\58\35\2\u045c\u046a\5> \2\u045d\u046a\5D#\2\u045e\u046a\5"+ 16364 "J&\2\u045f\u046a\5V,\2\u0460\u046a\5b\62\2\u0461\u046a\5\\/\2\u0462\u0463"+ 16365 "\6+\20\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094K\2\u0465\u046a\7\5\2"+ 16366 "\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468\u046a\5\u0092J\2\u0469"+ 16367 "\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469\u0447\3\2"+ 16368 "\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2\2\2\u0469"+ 16369 "\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469\u044e\3\2"+ 16370 "\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2\2\2\u0469"+ 16371 "\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469\u0455\3\2"+ 16372 "\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2\2\2\u0469"+ 16373 "\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469\u045c\3\2"+ 16374 "\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2\2\2\u0469"+ 16375 "\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469\u0464\3\2"+ 16376 "\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2\2\2\u0469"+ 16377 "\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2"+ 16378 "\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5R*\2\u046fU"+ 16379 "\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7I\2\2\u0472\u0477\5\n\6\2\u0473"+ 16380 "\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476\u0472\3\2"+ 16381 "\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477"+ 16382 "\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u047b\3\2"+ 16383 "\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cW\3\2\2\2\u047d\u047e"+ 16384 "\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7I\2\2\u0480\u0482\t\2\2\2\u0481"+ 16385 "\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484\3\2"+ 16386 "\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+ 16387 "Y\3\2\2\2\u0488\u04b0\5V,\2\u0489\u04af\5\f\7\2\u048a\u04af\5j\66\2\u048b"+ 16388 "\u04af\5\22\n\2\u048c\u04af\5\30\r\2\u048d\u04af\5\36\20\2\u048e\u04af"+ 16389 "\5$\23\2\u048f\u04af\5*\26\2\u0490\u04af\5\60\31\2\u0491\u04af\5\66\34"+ 16390 "\2\u0492\u04af\5<\37\2\u0493\u04af\5B\"\2\u0494\u04af\5H%\2\u0495\u04af"+ 16391 "\5N(\2\u0496\u04af\5T+\2\u0497\u04af\5f\64\2\u0498\u04af\5`\61\2\u0499"+ 16392 "\u04af\5\16\b\2\u049a\u04af\5\24\13\2\u049b\u04af\5\32\16\2\u049c\u04af"+ 16393 "\5 \21\2\u049d\u04af\5&\24\2\u049e\u04af\5,\27\2\u049f\u04af\5\62\32\2"+ 16394 "\u04a0\u04af\58\35\2\u04a1\u04af\5> \2\u04a2\u04af\5D#\2\u04a3\u04af\5"+ 16395 "J&\2\u04a4\u04af\5P)\2\u04a5\u04af\5b\62\2\u04a6\u04af\5\\/\2\u04a7\u04a8"+ 16396 "\6.\21\2\u04a8\u04af\7\3\2\2\u04a9\u04af\5\u0094K\2\u04aa\u04af\7\5\2"+ 16397 "\2\u04ab\u04af\7\b\2\2\u04ac\u04af\5\u0096L\2\u04ad\u04af\5\u0092J\2\u04ae"+ 16398 "\u0489\3\2\2\2\u04ae\u048a\3\2\2\2\u04ae\u048b\3\2\2\2\u04ae\u048c\3\2"+ 16399 "\2\2\u04ae\u048d\3\2\2\2\u04ae\u048e\3\2\2\2\u04ae\u048f\3\2\2\2\u04ae"+ 16400 "\u0490\3\2\2\2\u04ae\u0491\3\2\2\2\u04ae\u0492\3\2\2\2\u04ae\u0493\3\2"+ 16401 "\2\2\u04ae\u0494\3\2\2\2\u04ae\u0495\3\2\2\2\u04ae\u0496\3\2\2\2\u04ae"+ 16402 "\u0497\3\2\2\2\u04ae\u0498\3\2\2\2\u04ae\u0499\3\2\2\2\u04ae\u049a\3\2"+ 16403 "\2\2\u04ae\u049b\3\2\2\2\u04ae\u049c\3\2\2\2\u04ae\u049d\3\2\2\2\u04ae"+ 16404 "\u049e\3\2\2\2\u04ae\u049f\3\2\2\2\u04ae\u04a0\3\2\2\2\u04ae\u04a1\3\2"+ 16405 "\2\2\u04ae\u04a2\3\2\2\2\u04ae\u04a3\3\2\2\2\u04ae\u04a4\3\2\2\2\u04ae"+ 16406 "\u04a5\3\2\2\2\u04ae\u04a6\3\2\2\2\u04ae\u04a7\3\2\2\2\u04ae\u04a9\3\2"+ 16407 "\2\2\u04ae\u04aa\3\2\2\2\u04ae\u04ab\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae"+ 16408 "\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b0\u04b1\3\2"+ 16409 "\2\2\u04b1\u04b3\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04b4\5X-\2\u04b4["+ 16410 "\3\2\2\2\u04b5\u04b6\7\7\2\2\u04b6\u04bd\7J\2\2\u04b7\u04bc\5\n\6\2\u04b8"+ 16411 "\u04bc\7\b\2\2\u04b9\u04bc\7\3\2\2\u04ba\u04bc\7\6\2\2\u04bb\u04b7\3\2"+ 16412 "\2\2\u04bb\u04b8\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bb\u04ba\3\2\2\2\u04bc"+ 16413 "\u04bf\3\2\2\2\u04bd\u04bb\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04c0\3\2"+ 16414 "\2\2\u04bf\u04bd\3\2\2\2\u04c0\u04c1\79\2\2\u04c1]\3\2\2\2\u04c2\u04c3"+ 16415 "\7\7\2\2\u04c3\u04c4\7;\2\2\u04c4\u04c8\7J\2\2\u04c5\u04c7\t\2\2\2\u04c6"+ 16416 "\u04c5\3\2\2\2\u04c7\u04ca\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c8\u04c9\3\2"+ 16417 "\2\2\u04c9\u04cb\3\2\2\2\u04ca\u04c8\3\2\2\2\u04cb\u04cc\79\2\2\u04cc"+ 16418 "_\3\2\2\2\u04cd\u04f5\5\\/\2\u04ce\u04f4\5\f\7\2\u04cf\u04f4\5j\66\2\u04d0"+ 16419 "\u04f4\5\22\n\2\u04d1\u04f4\5\30\r\2\u04d2\u04f4\5\36\20\2\u04d3\u04f4"+ 16420 "\5$\23\2\u04d4\u04f4\5*\26\2\u04d5\u04f4\5\60\31\2\u04d6\u04f4\5\66\34"+ 16421 "\2\u04d7\u04f4\5<\37\2\u04d8\u04f4\5B\"\2\u04d9\u04f4\5H%\2\u04da\u04f4"+ 16422 "\5N(\2\u04db\u04f4\5T+\2\u04dc\u04f4\5Z.\2\u04dd\u04f4\5f\64\2\u04de\u04f4"+ 16423 "\5\16\b\2\u04df\u04f4\5\24\13\2\u04e0\u04f4\5\32\16\2\u04e1\u04f4\5 \21"+ 16424 "\2\u04e2\u04f4\5&\24\2\u04e3\u04f4\5,\27\2\u04e4\u04f4\5\62\32\2\u04e5"+ 16425 "\u04f4\58\35\2\u04e6\u04f4\5> \2\u04e7\u04f4\5D#\2\u04e8\u04f4\5J&\2\u04e9"+ 16426 "\u04f4\5P)\2\u04ea\u04f4\5V,\2\u04eb\u04f4\5b\62\2\u04ec\u04ed\6\61\22"+ 16427 "\2\u04ed\u04f4\7\3\2\2\u04ee\u04f4\5\u0094K\2\u04ef\u04f4\7\5\2\2\u04f0"+ 16428 "\u04f4\7\b\2\2\u04f1\u04f4\5\u0096L\2\u04f2\u04f4\5\u0092J\2\u04f3\u04ce"+ 16429 "\3\2\2\2\u04f3\u04cf\3\2\2\2\u04f3\u04d0\3\2\2\2\u04f3\u04d1\3\2\2\2\u04f3"+ 16430 "\u04d2\3\2\2\2\u04f3\u04d3\3\2\2\2\u04f3\u04d4\3\2\2\2\u04f3\u04d5\3\2"+ 16431 "\2\2\u04f3\u04d6\3\2\2\2\u04f3\u04d7\3\2\2\2\u04f3\u04d8\3\2\2\2\u04f3"+ 16432 "\u04d9\3\2\2\2\u04f3\u04da\3\2\2\2\u04f3\u04db\3\2\2\2\u04f3\u04dc\3\2"+ 16433 "\2\2\u04f3\u04dd\3\2\2\2\u04f3\u04de\3\2\2\2\u04f3\u04df\3\2\2\2\u04f3"+ 16434 "\u04e0\3\2\2\2\u04f3\u04e1\3\2\2\2\u04f3\u04e2\3\2\2\2\u04f3\u04e3\3\2"+ 16435 "\2\2\u04f3\u04e4\3\2\2\2\u04f3\u04e5\3\2\2\2\u04f3\u04e6\3\2\2\2\u04f3"+ 16436 "\u04e7\3\2\2\2\u04f3\u04e8\3\2\2\2\u04f3\u04e9\3\2\2\2\u04f3\u04ea\3\2"+ 16437 "\2\2\u04f3\u04eb\3\2\2\2\u04f3\u04ec\3\2\2\2\u04f3\u04ee\3\2\2\2\u04f3"+ 16438 "\u04ef\3\2\2\2\u04f3\u04f0\3\2\2\2\u04f3\u04f1\3\2\2\2\u04f3\u04f2\3\2"+ 16439 "\2\2\u04f4\u04f7\3\2\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6"+ 16440 "\u04f8\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f8\u04f9\5^\60\2\u04f9a\3\2\2\2"+ 16441 "\u04fa\u04fb\7\7\2\2\u04fb\u0502\7K\2\2\u04fc\u0501\5\n\6\2\u04fd\u0501"+ 16442 "\7\b\2\2\u04fe\u0501\7\3\2\2\u04ff\u0501\7\6\2\2\u0500\u04fc\3\2\2\2\u0500"+ 16443 "\u04fd\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u04ff\3\2\2\2\u0501\u0504\3\2"+ 16444 "\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0505\3\2\2\2\u0504"+ 16445 "\u0502\3\2\2\2\u0505\u0506\79\2\2\u0506c\3\2\2\2\u0507\u0508\7\7\2\2\u0508"+ 16446 "\u0509\7;\2\2\u0509\u050d\7K\2\2\u050a\u050c\t\2\2\2\u050b\u050a\3\2\2"+ 16447 "\2\u050c\u050f\3\2\2\2\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u0510"+ 16448 "\3\2\2\2\u050f\u050d\3\2\2\2\u0510\u0511\79\2\2\u0511e\3\2\2\2\u0512\u053a"+ 16449 "\5b\62\2\u0513\u0539\5\f\7\2\u0514\u0539\5j\66\2\u0515\u0539\5\22\n\2"+ 16450 "\u0516\u0539\5\30\r\2\u0517\u0539\5\36\20\2\u0518\u0539\5$\23\2\u0519"+ 16451 "\u0539\5*\26\2\u051a\u0539\5\60\31\2\u051b\u0539\5\66\34\2\u051c\u0539"+ 16452 "\5<\37\2\u051d\u0539\5B\"\2\u051e\u0539\5H%\2\u051f\u0539\5N(\2\u0520"+ 16453 "\u0539\5T+\2\u0521\u0539\5Z.\2\u0522\u0539\5`\61\2\u0523\u0539\5\16\b"+ 16454 "\2\u0524\u0539\5\24\13\2\u0525\u0539\5\32\16\2\u0526\u0539\5 \21\2\u0527"+ 16455 "\u0539\5&\24\2\u0528\u0539\5,\27\2\u0529\u0539\5\62\32\2\u052a\u0539\5"+ 16456 "8\35\2\u052b\u0539\5> \2\u052c\u0539\5D#\2\u052d\u0539\5J&\2\u052e\u0539"+ 16457 "\5P)\2\u052f\u0539\5V,\2\u0530\u0539\5\\/\2\u0531\u0532\6\64\23\2\u0532"+ 16458 "\u0539\7\3\2\2\u0533\u0539\5\u0094K\2\u0534\u0539\7\5\2\2\u0535\u0539"+ 16459 "\7\b\2\2\u0536\u0539\5\u0096L\2\u0537\u0539\5\u0092J\2\u0538\u0513\3\2"+ 16460 "\2\2\u0538\u0514\3\2\2\2\u0538\u0515\3\2\2\2\u0538\u0516\3\2\2\2\u0538"+ 16461 "\u0517\3\2\2\2\u0538\u0518\3\2\2\2\u0538\u0519\3\2\2\2\u0538\u051a\3\2"+ 16462 "\2\2\u0538\u051b\3\2\2\2\u0538\u051c\3\2\2\2\u0538\u051d\3\2\2\2\u0538"+ 16463 "\u051e\3\2\2\2\u0538\u051f\3\2\2\2\u0538\u0520\3\2\2\2\u0538\u0521\3\2"+ 16464 "\2\2\u0538\u0522\3\2\2\2\u0538\u0523\3\2\2\2\u0538\u0524\3\2\2\2\u0538"+ 16465 "\u0525\3\2\2\2\u0538\u0526\3\2\2\2\u0538\u0527\3\2\2\2\u0538\u0528\3\2"+ 16466 "\2\2\u0538\u0529\3\2\2\2\u0538\u052a\3\2\2\2\u0538\u052b\3\2\2\2\u0538"+ 16467 "\u052c\3\2\2\2\u0538\u052d\3\2\2\2\u0538\u052e\3\2\2\2\u0538\u052f\3\2"+ 16468 "\2\2\u0538\u0530\3\2\2\2\u0538\u0531\3\2\2\2\u0538\u0533\3\2\2\2\u0538"+ 16469 "\u0534\3\2\2\2\u0538\u0535\3\2\2\2\u0538\u0536\3\2\2\2\u0538\u0537\3\2"+ 16470 "\2\2\u0539\u053c\3\2\2\2\u053a\u0538\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+ 16471 "\u053d\3\2\2\2\u053c\u053a\3\2\2\2\u053d\u053e\5d\63\2\u053eg\3\2\2\2"+ 16472 "\u053f\u054f\5j\66\2\u0540\u054f\5l\67\2\u0541\u054f\5n8\2\u0542\u054f"+ 16473 "\5p9\2\u0543\u054f\5r:\2\u0544\u054f\5t;\2\u0545\u054f\5v<\2\u0546\u054f"+ 16474 "\5x=\2\u0547\u054f\5z>\2\u0548\u054f\5|?\2\u0549\u054f\5~@\2\u054a\u054f"+ 16475 "\5\u0080A\2\u054b\u054f\5\u0082B\2\u054c\u054f\5\u0084C\2\u054d\u054f"+ 16476 "\5\u0086D\2\u054e\u053f\3\2\2\2\u054e\u0540\3\2\2\2\u054e\u0541\3\2\2"+ 16477 "\2\u054e\u0542\3\2\2\2\u054e\u0543\3\2\2\2\u054e\u0544\3\2\2\2\u054e\u0545"+ 16478 "\3\2\2\2\u054e\u0546\3\2\2\2\u054e\u0547\3\2\2\2\u054e\u0548\3\2\2\2\u054e"+ 16479 "\u0549\3\2\2\2\u054e\u054a\3\2\2\2\u054e\u054b\3\2\2\2\u054e\u054c\3\2"+ 16480 "\2\2\u054e\u054d\3\2\2\2\u054fi\3\2\2\2\u0550\u0551\7\7\2\2\u0551\u0558"+ 16481 "\t\3\2\2\u0552\u0557\5\n\6\2\u0553\u0557\7\b\2\2\u0554\u0557\7\3\2\2\u0555"+ 16482 "\u0557\7\6\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+ 16483 "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+ 16484 "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7:"+ 16485 "\2\2\u055ck\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7L\2\2\u055f\u0564"+ 16486 "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+ 16487 "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+ 16488 "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+ 16489 "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\t\4\2\2\u0569m\3\2\2\2"+ 16490 "\u056a\u056b\7\7\2\2\u056b\u0572\7M\2\2\u056c\u0571\5\n\6\2\u056d\u0571"+ 16491 "\7\b\2\2\u056e\u0571\7\3\2\2\u056f\u0571\7\6\2\2\u0570\u056c\3\2\2\2\u0570"+ 16492 "\u056d\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2"+ 16493 "\2\2\u0572\u0570\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574"+ 16494 "\u0572\3\2\2\2\u0575\u0576\t\4\2\2\u0576o\3\2\2\2\u0577\u0578\7\7\2\2"+ 16495 "\u0578\u057f\7N\2\2\u0579\u057e\5\n\6\2\u057a\u057e\7\b\2\2\u057b\u057e"+ 16496 "\7\3\2\2\u057c\u057e\7\6\2\2\u057d\u0579\3\2\2\2\u057d\u057a\3\2\2\2\u057d"+ 16497 "\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e\u0581\3\2\2\2\u057f\u057d\3\2"+ 16498 "\2\2\u057f\u0580\3\2\2\2\u0580\u0582\3\2\2\2\u0581\u057f\3\2\2\2\u0582"+ 16499 "\u0583\t\4\2\2\u0583q\3\2\2\2\u0584\u0585\7\7\2\2\u0585\u058c\7O\2\2\u0586"+ 16500 "\u058b\5\n\6\2\u0587\u058b\7\b\2\2\u0588\u058b\7\3\2\2\u0589\u058b\7\6"+ 16501 "\2\2\u058a\u0586\3\2\2\2\u058a\u0587\3\2\2\2\u058a\u0588\3\2\2\2\u058a"+ 16502 "\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2\2\2\u058c\u058d\3\2"+ 16503 "\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f\u0590\t\4\2\2\u0590"+ 16504 "s\3\2\2\2\u0591\u0592\7\7\2\2\u0592\u0599\7P\2\2\u0593\u0598\5\n\6\2\u0594"+ 16505 "\u0598\7\b\2\2\u0595\u0598\7\3\2\2\u0596\u0598\7\6\2\2\u0597\u0593\3\2"+ 16506 "\2\2\u0597\u0594\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0596\3\2\2\2\u0598"+ 16507 "\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c\3\2"+ 16508 "\2\2\u059b\u0599\3\2\2\2\u059c\u059d\t\4\2\2\u059du\3\2\2\2\u059e\u059f"+ 16509 "\7\7\2\2\u059f\u05a6\7Q\2\2\u05a0\u05a5\5\n\6\2\u05a1\u05a5\7\b\2\2\u05a2"+ 16510 "\u05a5\7\3\2\2\u05a3\u05a5\7\6\2\2\u05a4\u05a0\3\2\2\2\u05a4\u05a1\3\2"+ 16511 "\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3\3\2\2\2\u05a5\u05a8\3\2\2\2\u05a6"+ 16512 "\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a9\3\2\2\2\u05a8\u05a6\3\2"+ 16513 "\2\2\u05a9\u05aa\t\4\2\2\u05aaw\3\2\2\2\u05ab\u05ac\7\7\2\2\u05ac\u05b3"+ 16514 "\7R\2\2\u05ad\u05b2\5\n\6\2\u05ae\u05b2\7\b\2\2\u05af\u05b2\7\3\2\2\u05b0"+ 16515 "\u05b2\7\6\2\2\u05b1\u05ad\3\2\2\2\u05b1\u05ae\3\2\2\2\u05b1\u05af\3\2"+ 16516 "\2\2\u05b1\u05b0\3\2\2\2\u05b2\u05b5\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b3"+ 16517 "\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b3\3\2\2\2\u05b6\u05b7\t\4"+ 16518 "\2\2\u05b7y\3\2\2\2\u05b8\u05b9\7\7\2\2\u05b9\u05c0\7S\2\2\u05ba\u05bf"+ 16519 "\5\n\6\2\u05bb\u05bf\7\b\2\2\u05bc\u05bf\7\3\2\2\u05bd\u05bf\7\6\2\2\u05be"+ 16520 "\u05ba\3\2\2\2\u05be\u05bb\3\2\2\2\u05be\u05bc\3\2\2\2\u05be\u05bd\3\2"+ 16521 "\2\2\u05bf\u05c2\3\2\2\2\u05c0\u05be\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1"+ 16522 "\u05c3\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c3\u05c4\t\4\2\2\u05c4{\3\2\2\2"+ 16523 "\u05c5\u05c6\7\7\2\2\u05c6\u05cd\7T\2\2\u05c7\u05cc\5\n\6\2\u05c8\u05cc"+ 16524 "\7\b\2\2\u05c9\u05cc\7\3\2\2\u05ca\u05cc\7\6\2\2\u05cb\u05c7\3\2\2\2\u05cb"+ 16525 "\u05c8\3\2\2\2\u05cb\u05c9\3\2\2\2\u05cb\u05ca\3\2\2\2\u05cc\u05cf\3\2"+ 16526 "\2\2\u05cd\u05cb\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05d0\3\2\2\2\u05cf"+ 16527 "\u05cd\3\2\2\2\u05d0\u05d1\t\4\2\2\u05d1}\3\2\2\2\u05d2\u05d3\7\7\2\2"+ 16528 "\u05d3\u05da\7U\2\2\u05d4\u05d9\5\n\6\2\u05d5\u05d9\7\b\2\2\u05d6\u05d9"+ 16529 "\7\3\2\2\u05d7\u05d9\7\6\2\2\u05d8\u05d4\3\2\2\2\u05d8\u05d5\3\2\2\2\u05d8"+ 16530 "\u05d6\3\2\2\2\u05d8\u05d7\3\2\2\2\u05d9\u05dc\3\2\2\2\u05da\u05d8\3\2"+ 16531 "\2\2\u05da\u05db\3\2\2\2\u05db\u05dd\3\2\2\2\u05dc\u05da\3\2\2\2\u05dd"+ 16532 "\u05de\t\4\2\2\u05de\177\3\2\2\2\u05df\u05e0\7\7\2\2\u05e0\u05e7\7V\2"+ 16533 "\2\u05e1\u05e6\5\n\6\2\u05e2\u05e6\7\b\2\2\u05e3\u05e6\7\3\2\2\u05e4\u05e6"+ 16534 "\7\6\2\2\u05e5\u05e1\3\2\2\2\u05e5\u05e2\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5"+ 16535 "\u05e4\3\2\2\2\u05e6\u05e9\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e7\u05e8\3\2"+ 16536 "\2\2\u05e8\u05ea\3\2\2\2\u05e9\u05e7\3\2\2\2\u05ea\u05eb\t\4\2\2\u05eb"+ 16537 "\u0081\3\2\2\2\u05ec\u05ed\7\7\2\2\u05ed\u05f4\7W\2\2\u05ee\u05f3\5\n"+ 16538 "\6\2\u05ef\u05f3\7\b\2\2\u05f0\u05f3\7\3\2\2\u05f1\u05f3\7\6\2\2\u05f2"+ 16539 "\u05ee\3\2\2\2\u05f2\u05ef\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f1\3\2"+ 16540 "\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5"+ 16541 "\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\t\4\2\2\u05f8\u0083\3\2"+ 16542 "\2\2\u05f9\u05fa\7\7\2\2\u05fa\u0601\7X\2\2\u05fb\u0600\5\n\6\2\u05fc"+ 16543 "\u0600\7\b\2\2\u05fd\u0600\7\3\2\2\u05fe\u0600\7\6\2\2\u05ff\u05fb\3\2"+ 16544 "\2\2\u05ff\u05fc\3\2\2\2\u05ff\u05fd\3\2\2\2\u05ff\u05fe\3\2\2\2\u0600"+ 16545 "\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0604\3\2"+ 16546 "\2\2\u0603\u0601\3\2\2\2\u0604\u0605\t\4\2\2\u0605\u0085\3\2\2\2\u0606"+ 16547 "\u0607\7\7\2\2\u0607\u0608\7;\2\2\u0608\u0609\5\u0088E\2\u0609\u060a\7"+ 16548 "9\2\2\u060a\u060b\bD\1\2\u060b\u0087\3\2\2\2\u060c\u060d\t\5\2\2\u060d"+ 16549 "\u0089\3\2\2\2\u060e\u060f\6F\24\2\u060f\u0617\7\3\2\2\u0610\u0617\5\u0094"+ 16550 "K\2\u0611\u0617\7\5\2\2\u0612\u0617\7\b\2\2\u0613\u0617\5\u0096L\2\u0614"+ 16551 "\u0617\5\u0092J\2\u0615\u0617\5\4\3\2\u0616\u060e\3\2\2\2\u0616\u0610"+ 16552 "\3\2\2\2\u0616\u0611\3\2\2\2\u0616\u0612\3\2\2\2\u0616\u0613\3\2\2\2\u0616"+ 16553 "\u0614\3\2\2\2\u0616\u0615\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u0616\3\2"+ 16554 "\2\2\u0618\u0619\3\2\2\2\u0619\u008b\3\2\2\2\u061a\u061e\7\36\2\2\u061b"+ 16555 "\u061d\t\6\2\2\u061c\u061b\3\2\2\2\u061d\u0620\3\2\2\2\u061e\u061c\3\2"+ 16556 "\2\2\u061e\u061f\3\2\2\2\u061f\u0622\3\2\2\2\u0620\u061e\3\2\2\2\u0621"+ 16557 "\u0623\7 \2\2\u0622\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2"+ 16558 "\2\2\u0624\u0626\7#\2\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626"+ 16559 "\u0628\3\2\2\2\u0627\u0629\5\u008eH\2\u0628\u0627\3\2\2\2\u0628\u0629"+ 16560 "\3\2\2\2\u0629\u0640\3\2\2\2\u062a\u062c\t\6\2\2\u062b\u062a\3\2\2\2\u062c"+ 16561 "\u062d\3\2\2\2\u062d\u062b\3\2\2\2\u062d\u062e\3\2\2\2\u062e\u0630\3\2"+ 16562 "\2\2\u062f\u0631\7 \2\2\u0630\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631"+ 16563 "\u0633\3\2\2\2\u0632\u0634\7#\2\2\u0633\u0632\3\2\2\2\u0633\u0634\3\2"+ 16564 "\2\2\u0634\u0636\3\2\2\2\u0635\u0637\5\u008eH\2\u0636\u0635\3\2\2\2\u0636"+ 16565 "\u0637\3\2\2\2\u0637\u0640\3\2\2\2\u0638\u063a\7 \2\2\u0639\u0638\3\2"+ 16566 "\2\2\u0639\u063a\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063d\7#\2\2\u063c"+ 16567 "\u063e\5\u008eH\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0640"+ 16568 "\3\2\2\2\u063f\u061a\3\2\2\2\u063f\u062b\3\2\2\2\u063f\u0639\3\2\2\2\u0640"+ 16569 "\u008d\3\2\2\2\u0641\u0645\7$\2\2\u0642\u0644\t\7\2\2\u0643\u0642\3\2"+ 16570 "\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646"+ 16571 "\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649\7%\2\2\u0649\u008f\3\2"+ 16572 "\2\2\u064a\u064e\7\t\2\2\u064b\u064d\t\b\2\2\u064c\u064b\3\2\2\2\u064d"+ 16573 "\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f\3\2\2\2\u064f\u0652\3\2"+ 16574 "\2\2\u0650\u064e\3\2\2\2\u0651\u0653\5\u008aF\2\u0652\u0651\3\2\2\2\u0652"+ 16575 "\u0653\3\2\2\2\u0653\u070d\3\2\2\2\u0654\u0658\7\n\2\2\u0655\u0657\t\b"+ 16576 "\2\2\u0656\u0655\3\2\2\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+ 16577 "\u0659\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065b\u065d\5\u008a"+ 16578 "F\2\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u070d\3\2\2\2\u065e"+ 16579 "\u0662\7\13\2\2\u065f\u0661\t\b\2\2\u0660\u065f\3\2\2\2\u0661\u0664\3"+ 16580 "\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0666\3\2\2\2\u0664"+ 16581 "\u0662\3\2\2\2\u0665\u0667\7-\2\2\u0666\u0665\3\2\2\2\u0666\u0667\3\2"+ 16582 "\2\2\u0667\u066b\3\2\2\2\u0668\u066a\t\b\2\2\u0669\u0668\3\2\2\2\u066a"+ 16583 "\u066d\3\2\2\2\u066b\u0669\3\2\2\2\u066b\u066c\3\2\2\2\u066c\u066f\3\2"+ 16584 "\2\2\u066d\u066b\3\2\2\2\u066e\u0670\5\u008aF\2\u066f\u066e\3\2\2\2\u066f"+ 16585 "\u0670\3\2\2\2\u0670\u070d\3\2\2\2\u0671\u0675\7\f\2\2\u0672\u0674\t\b"+ 16586 "\2\2\u0673\u0672\3\2\2\2\u0674\u0677\3\2\2\2\u0675\u0673\3\2\2\2\u0675"+ 16587 "\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0675\3\2\2\2\u0678\u067a\7\33"+ 16588 "\2\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067e\3\2\2\2\u067b"+ 16589 "\u067d\t\b\2\2\u067c\u067b\3\2\2\2\u067d\u0680\3\2\2\2\u067e\u067c\3\2"+ 16590 "\2\2\u067e\u067f\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e\3\2\2\2\u0681"+ 16591 "\u0683\5\u008aF\2\u0682\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u070d"+ 16592 "\3\2\2\2\u0684\u0688\7\r\2\2\u0685\u0687\t\b\2\2\u0686\u0685\3\2\2\2\u0687"+ 16593 "\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068c\3\2"+ 16594 "\2\2\u068a\u0688\3\2\2\2\u068b\u068d\5\u008aF\2\u068c\u068b\3\2\2\2\u068c"+ 16595 "\u068d\3\2\2\2\u068d\u070d\3\2\2\2\u068e\u0692\7\16\2\2\u068f\u0691\t"+ 16596 "\b\2\2\u0690\u068f\3\2\2\2\u0691\u0694\3\2\2\2\u0692\u0690\3\2\2\2\u0692"+ 16597 "\u0693\3\2\2\2\u0693\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695\u0697\5\u008c"+ 16598 "G\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069c\3\2\2\2\u0698"+ 16599 "\u069b\7\35\2\2\u0699\u069b\5\4\3\2\u069a\u0698\3\2\2\2\u069a\u0699\3"+ 16600 "\2\2\2\u069b\u069e\3\2\2\2\u069c\u069a\3\2\2\2\u069c\u069d\3\2\2\2\u069d"+ 16601 "\u06a2\3\2\2\2\u069e\u069c\3\2\2\2\u069f\u06a1\t\b\2\2\u06a0\u069f\3\2"+ 16602 "\2\2\u06a1\u06a4\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3"+ 16603 "\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a5\u06a7\5\u008aF\2\u06a6\u06a5"+ 16604 "\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u070d\3\2\2\2\u06a8\u06ac\7\17\2\2"+ 16605 "\u06a9\u06ab\t\b\2\2\u06aa\u06a9\3\2\2\2\u06ab\u06ae\3\2\2\2\u06ac\u06aa"+ 16606 "\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06b0\3\2\2\2\u06ae\u06ac\3\2\2\2\u06af"+ 16607 "\u06b1\t\t\2\2\u06b0\u06af\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b3\3\2"+ 16608 "\2\2\u06b2\u06b4\5\u008aF\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4"+ 16609 "\u070d\3\2\2\2\u06b5\u06b9\7\21\2\2\u06b6\u06b8\t\b\2\2\u06b7\u06b6\3"+ 16610 "\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba"+ 16611 "\u06bd\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5\u008aF\2\u06bd\u06bc"+ 16612 "\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u070d\3\2\2\2\u06bf\u06c3\7\20\2\2"+ 16613 "\u06c0\u06c2\t\b\2\2\u06c1\u06c0\3\2\2\2\u06c2\u06c5\3\2\2\2\u06c3\u06c1"+ 16614 "\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2\2\2\u06c6"+ 16615 "\u06c8\7)\2\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cc\3\2"+ 16616 "\2\2\u06c9\u06cb\t\b\2\2\u06ca\u06c9\3\2\2\2\u06cb\u06ce\3\2\2\2\u06cc"+ 16617 "\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06d0\3\2\2\2\u06ce\u06cc\3\2"+ 16618 "\2\2\u06cf\u06d1\7+\2\2\u06d0\u06cf\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1"+ 16619 "\u06d5\3\2\2\2\u06d2\u06d4\t\b\2\2\u06d3\u06d2\3\2\2\2\u06d4\u06d7\3\2"+ 16620 "\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d9\3\2\2\2\u06d7"+ 16621 "\u06d5\3\2\2\2\u06d8\u06da\5\u008aF\2\u06d9\u06d8\3\2\2\2\u06d9\u06da"+ 16622 "\3\2\2\2\u06da\u070d\3\2\2\2\u06db\u06df\7\22\2\2\u06dc\u06de\t\b\2\2"+ 16623 "\u06dd\u06dc\3\2\2\2\u06de\u06e1\3\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06e0"+ 16624 "\3\2\2\2\u06e0\u06e3\3\2\2\2\u06e1\u06df\3\2\2\2\u06e2\u06e4\5\u008aF"+ 16625 "\2\u06e3\u06e2\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u070d\3\2\2\2\u06e5\u06e9"+ 16626 "\7\23\2\2\u06e6\u06e8\t\b\2\2\u06e7\u06e6\3\2\2\2\u06e8\u06eb\3\2\2\2"+ 16627 "\u06e9\u06e7\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb\u06e9"+ 16628 "\3\2\2\2\u06ec\u06ee\7-\2\2\u06ed\u06ec\3\2\2\2\u06ed\u06ee\3\2\2\2\u06ee"+ 16629 "\u06f2\3\2\2\2\u06ef\u06f1\t\b\2\2\u06f0\u06ef\3\2\2\2\u06f1\u06f4\3\2"+ 16630 "\2\2\u06f2\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f6\3\2\2\2\u06f4"+ 16631 "\u06f2\3\2\2\2\u06f5\u06f7\5\u008aF\2\u06f6\u06f5\3\2\2\2\u06f6\u06f7"+ 16632 "\3\2\2\2\u06f7\u070d\3\2\2\2\u06f8\u06fc\7\24\2\2\u06f9\u06fb\t\b\2\2"+ 16633 "\u06fa\u06f9\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd"+ 16634 "\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06ff\u0701\5\u008aF"+ 16635 "\2\u0700\u06ff\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u070d\3\2\2\2\u0702\u0706"+ 16636 "\7\27\2\2\u0703\u0705\t\b\2\2\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2"+ 16637 "\u0706\u0704\3\2\2\2\u0706\u0707\3\2\2\2\u0707\u070a\3\2\2\2\u0708\u0706"+ 16638 "\3\2\2\2\u0709\u070b\5\u008aF\2\u070a\u0709\3\2\2\2\u070a\u070b\3\2\2"+ 16639 "\2\u070b\u070d\3\2\2\2\u070c\u064a\3\2\2\2\u070c\u0654\3\2\2\2\u070c\u065e"+ 16640 "\3\2\2\2\u070c\u0671\3\2\2\2\u070c\u0684\3\2\2\2\u070c\u068e\3\2\2\2\u070c"+ 16641 "\u06a8\3\2\2\2\u070c\u06b5\3\2\2\2\u070c\u06bf\3\2\2\2\u070c\u06db\3\2"+ 16642 "\2\2\u070c\u06e5\3\2\2\2\u070c\u06f8\3\2\2\2\u070c\u0702\3\2\2\2\u070d"+ 16643 "\u0091\3\2\2\2\u070e\u075b\7\25\2\2\u070f\u0716\7/\2\2\u0710\u0715\7\6"+ 16644 "\2\2\u0711\u0715\7\b\2\2\u0712\u0715\7\3\2\2\u0713\u0715\5\u0096L\2\u0714"+ 16645 "\u0710\3\2\2\2\u0714\u0711\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0713\3\2"+ 16646 "\2\2\u0715\u0718\3\2\2\2\u0716\u0714\3\2\2\2\u0716\u0717\3\2\2\2\u0717"+ 16647 "\u075c\3\2\2\2\u0718\u0716\3\2\2\2\u0719\u071d\7\60\2\2\u071a\u071c\t"+ 16648 "\2\2\2\u071b\u071a\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2\2\2\u071d"+ 16649 "\u071e\3\2\2\2\u071e\u075c\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0724\7\61"+ 16650 "\2\2\u0721\u0723\t\2\2\2\u0722\u0721\3\2\2\2\u0723\u0726\3\2\2\2\u0724"+ 16651 "\u0722\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u075c\3\2\2\2\u0726\u0724\3\2"+ 16652 "\2\2\u0727\u072b\7\62\2\2\u0728\u072a\t\2\2\2\u0729\u0728\3\2\2\2\u072a"+ 16653 "\u072d\3\2\2\2\u072b\u0729\3\2\2\2\u072b\u072c\3\2\2\2\u072c\u072e\3\2"+ 16654 "\2\2\u072d\u072b\3\2\2\2\u072e\u0730\5\u008cG\2\u072f\u0731\5\u008aF\2"+ 16655 "\u0730\u072f\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u075c\3\2\2\2\u0732\u0736"+ 16656 "\7\63\2\2\u0733\u0735\t\2\2\2\u0734\u0733\3\2\2\2\u0735\u0738\3\2\2\2"+ 16657 "\u0736\u0734\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u0739\3\2\2\2\u0738\u0736"+ 16658 "\3\2\2\2\u0739\u073b\5\u008cG\2\u073a\u073c\5\u008aF\2\u073b\u073a\3\2"+ 16659 "\2\2\u073b\u073c\3\2\2\2\u073c\u075c\3\2\2\2\u073d\u0744\7\64\2\2\u073e"+ 16660 "\u0743\7\6\2\2\u073f\u0743\7\b\2\2\u0740\u0743\7\3\2\2\u0741\u0743\5\u0096"+ 16661 "L\2\u0742\u073e\3\2\2\2\u0742\u073f\3\2\2\2\u0742\u0740\3\2\2\2\u0742"+ 16662 "\u0741\3\2\2\2\u0743\u0746\3\2\2\2\u0744\u0742\3\2\2\2\u0744\u0745\3\2"+ 16663 "\2\2\u0745\u075c\3\2\2\2\u0746\u0744\3\2\2\2\u0747\u074b\7\65\2\2\u0748"+ 16664 "\u074a\t\2\2\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749\3\2"+ 16665 "\2\2\u074b\u074c\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+ 16666 "\u0750\5\u008cG\2\u074f\u074e\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u075c"+ 16667 "\3\2\2\2\u0751\u0755\7\27\2\2\u0752\u0754\t\2\2\2\u0753\u0752\3\2\2\2"+ 16668 "\u0754\u0757\3\2\2\2\u0755\u0753\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0759"+ 16669 "\3\2\2\2\u0757\u0755\3\2\2\2\u0758\u075a\5\u008aF\2\u0759\u0758\3\2\2"+ 16670 "\2\u0759\u075a\3\2\2\2\u075a\u075c\3\2\2\2\u075b\u070f\3\2\2\2\u075b\u0719"+ 16671 "\3\2\2\2\u075b\u0720\3\2\2\2\u075b\u0727\3\2\2\2\u075b\u0732\3\2\2\2\u075b"+ 16672 "\u073d\3\2\2\2\u075b\u0747\3\2\2\2\u075b\u0751\3\2\2\2\u075c\u075d\3\2"+ 16673 "\2\2\u075d\u075e\7\26\2\2\u075e\u0093\3\2\2\2\u075f\u0765\7\4\2\2\u0760"+ 16674 "\u0764\5\u0096L\2\u0761\u0764\7\b\2\2\u0762\u0764\7\3\2\2\u0763\u0760"+ 16675 "\3\2\2\2\u0763\u0761\3\2\2\2\u0763\u0762\3\2\2\2\u0764\u0767\3\2\2\2\u0765"+ 16676 "\u0763\3\2\2\2\u0765\u0766\3\2\2\2\u0766\u0768\3\2\2\2\u0767\u0765\3\2"+ 16677 "\2\2\u0768\u0769\7]\2\2\u0769\u0095\3\2\2\2\u076a\u076b\t\n\2\2\u076b"+ 16678 "\u076d\bL\1\2\u076c\u076a\3\2\2\2\u076d\u076e\3\2\2\2\u076e\u076c\3\2"+ 16679 "\2\2\u076e\u076f\3\2\2\2\u076f\u0097\3\2\2\2\u00c5\u00a0\u00a2\u00a6\u00ab"+ 16680 "\u00b1\u00e5\u00ed\u00ef\u00fa\u0103\u010a\u0110\u011b\u011d\u012b\u012d"+ 16681 "\u0132\u013a\u013c\u0147\u0172\u0174\u017f\u0181\u018c\u01b7\u01b9\u01c4"+ 16682 "\u01c6\u01d1\u01fc\u01fe\u0209\u020b\u0216\u0241\u0243\u024e\u0250\u025b"+ 16683 "\u0286\u0288\u0293\u0295\u02a0\u02cb\u02cd\u02d8\u02da\u02e5\u0310\u0312"+ 16684 "\u031d\u031f\u032a\u0355\u0357\u0362\u0364\u036f\u039a\u039c\u03a7\u03a9"+ 16685 "\u03b4\u03df\u03e1\u03ec\u03ee\u03f9\u0424\u0426\u0431\u0433\u043e\u0469"+ 16686 "\u046b\u0476\u0478\u0483\u04ae\u04b0\u04bb\u04bd\u04c8\u04f3\u04f5\u0500"+ 16687 "\u0502\u050d\u0538\u053a\u054e\u0556\u0558\u0563\u0565\u0570\u0572\u057d"+ 16688 "\u057f\u058a\u058c\u0597\u0599\u05a4\u05a6\u05b1\u05b3\u05be\u05c0\u05cb"+ 16689 "\u05cd\u05d8\u05da\u05e5\u05e7\u05f2\u05f4\u05ff\u0601\u0616\u0618\u061e"+ 16690 "\u0622\u0625\u0628\u062d\u0630\u0633\u0636\u0639\u063d\u063f\u0645\u064e"+ 16691 "\u0652\u0658\u065c\u0662\u0666\u066b\u066f\u0675\u0679\u067e\u0682\u0688"+ 16692 "\u068c\u0692\u0696\u069a\u069c\u06a2\u06a6\u06ac\u06b0\u06b3\u06b9\u06bd"+ 16693 "\u06c3\u06c7\u06cc\u06d0\u06d5\u06d9\u06df\u06e3\u06e9\u06ed\u06f2\u06f6"+ 16694 "\u06fc\u0700\u0706\u070a\u070c\u0714\u0716\u071d\u0724\u072b\u0730\u0736"+ 16695 "\u073b\u0742\u0744\u074b\u074f\u0755\u0759\u075b\u0763\u0765\u076e"; 16696 public static final ATN _ATN = 16697 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 16698 static { 16699 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; 16700 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { 16701 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); 16702 } 16703 } 16704}