001// Generated from com/puppycrawl/tools/checkstyle/grammars/javadoc/JavadocParser.g4 by ANTLR 4.7 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.7", 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 public static final String[] ruleNames = { 063 "javadoc", "htmlElement", "htmlElementOpen", "htmlElementClose", "attribute", 064 "htmlTag", "pTagOpen", "pTagClose", "paragraph", "liTagOpen", "liTagClose", 065 "li", "trTagOpen", "trTagClose", "tr", "tdTagOpen", "tdTagClose", "td", 066 "thTagOpen", "thTagClose", "th", "bodyTagOpen", "bodyTagClose", "body", 067 "colgroupTagOpen", "colgroupTagClose", "colgroup", "ddTagOpen", "ddTagClose", 068 "dd", "dtTagOpen", "dtTagClose", "dt", "headTagOpen", "headTagClose", 069 "head", "htmlTagOpen", "htmlTagClose", "html", "optionTagOpen", "optionTagClose", 070 "option", "tbodyTagOpen", "tbodyTagClose", "tbody", "tfootTagOpen", "tfootTagClose", 071 "tfoot", "theadTagOpen", "theadTagClose", "thead", "singletonElement", 072 "singletonTag", "areaTag", "baseTag", "basefontTag", "brTag", "colTag", 073 "frameTag", "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", 074 "paramTag", "wrongSinletonTag", "singletonTagName", "description", "reference", 075 "parameters", "javadocTag", "javadocInlineTag", "htmlComment", "text" 076 }; 077 078 private static final String[] _LITERAL_NAMES = { 079 null, null, null, null, null, null, null, "'@author'", "'@deprecated'", 080 null, null, "'@return'", null, "'@serial'", null, "'@serialData'", "'@since'", 081 null, "'@version'", null, null, null, "'include'", "'exclude'", null, 082 null, null, null, null, "'.'", null, null, null, null, "'('", "')'", null, 083 "','", null, null, null, null, null, null, null, null, "'@docRoot'", "'@inheritDoc'", 084 "'@link'", "'@linkplain'", null, "'@value'", null, null, null, null, null, 085 "'/'", "'='", null, null, null, null, null, null, null, null, null, null, 086 null, null, null, null, null, null, null, null, null, null, null, null, 087 null, null, null, null, null, null, null, null, null, null, "'-->'" 088 }; 089 private static final String[] _SYMBOLIC_NAMES = { 090 null, "LEADING_ASTERISK", "HTML_COMMENT_START", "CDATA", "WS", "OPEN", 091 "NEWLINE", "AUTHOR_LITERAL", "DEPRECATED_LITERAL", "EXCEPTION_LITERAL", 092 "PARAM_LITERAL", "RETURN_LITERAL", "SEE_LITERAL", "SERIAL_LITERAL", "SERIAL_FIELD_LITERAL", 093 "SERIAL_DATA_LITERAL", "SINCE_LITERAL", "THROWS_LITERAL", "VERSION_LITERAL", 094 "JAVADOC_INLINE_TAG_START", "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", "LITERAL_INCLUDE", 095 "LITERAL_EXCLUDE", "CHAR", "PARAMETER_NAME", "Char1", "STRING", "PACKAGE", 096 "DOT", "HASH", "CLASS", "Char2", "MEMBER", "LEFT_BRACE", "RIGHT_BRACE", 097 "ARGUMENT", "COMMA", "Char20", "FIELD_NAME", "Char3", "FIELD_TYPE", "Char4", 098 "CLASS_NAME", "Char5", "CODE_LITERAL", "DOC_ROOT_LITERAL", "INHERIT_DOC_LITERAL", 099 "LINK_LITERAL", "LINKPLAIN_LITERAL", "LITERAL_LITERAL", "VALUE_LITERAL", 100 "Char7", "Char8", "Char10", "CLOSE", "SLASH_CLOSE", "SLASH", "EQUALS", 101 "P_HTML_TAG_NAME", "LI_HTML_TAG_NAME", "TR_HTML_TAG_NAME", "TD_HTML_TAG_NAME", 102 "TH_HTML_TAG_NAME", "BODY_HTML_TAG_NAME", "COLGROUP_HTML_TAG_NAME", "DD_HTML_TAG_NAME", 103 "DT_HTML_TAG_NAME", "HEAD_HTML_TAG_NAME", "HTML_HTML_TAG_NAME", "OPTION_HTML_TAG_NAME", 104 "TBODY_HTML_TAG_NAME", "TFOOT_HTML_TAG_NAME", "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", 105 "BASE_HTML_TAG_NAME", "BASEFONT_HTML_TAG_NAME", "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", 106 "FRAME_HTML_TAG_NAME", "HR_HTML_TAG_NAME", "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", 107 "ISINDEX_HTML_TAG_NAME", "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", 108 "HTML_TAG_NAME", "Char11", "ATTR_VALUE", "Char12", "HTML_COMMENT_END" 109 }; 110 public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); 111 112 /** 113 * @deprecated Use {@link #VOCABULARY} instead. 114 */ 115 @Deprecated 116 public static final String[] tokenNames; 117 static { 118 tokenNames = new String[_SYMBOLIC_NAMES.length]; 119 for (int i = 0; i < tokenNames.length; i++) { 120 tokenNames[i] = VOCABULARY.getLiteralName(i); 121 if (tokenNames[i] == null) { 122 tokenNames[i] = VOCABULARY.getSymbolicName(i); 123 } 124 125 if (tokenNames[i] == null) { 126 tokenNames[i] = "<INVALID>"; 127 } 128 } 129 } 130 131 @Override 132 @Deprecated 133 public String[] getTokenNames() { 134 return tokenNames; 135 } 136 137 @Override 138 139 public Vocabulary getVocabulary() { 140 return VOCABULARY; 141 } 142 143 @Override 144 public String getGrammarFileName() { return "JavadocParser.g4"; } 145 146 @Override 147 public String[] getRuleNames() { return ruleNames; } 148 149 @Override 150 public String getSerializedATN() { return _serializedATN; } 151 152 @Override 153 public ATN getATN() { return _ATN; } 154 155 156 boolean isNextJavadocTag() { 157 int token1 = _input.LA(2); 158 int token2 = _input.LA(3); 159 return isJavadocTag(token1) 160 || (token1 == WS && isJavadocTag(token2)); 161 } 162 163 boolean isJavadocTag(int type) { 164 switch(type) { 165 case AUTHOR_LITERAL: 166 case DEPRECATED_LITERAL: 167 case EXCEPTION_LITERAL: 168 case PARAM_LITERAL: 169 case RETURN_LITERAL: 170 case SEE_LITERAL: 171 case SERIAL_LITERAL: 172 case SERIAL_FIELD_LITERAL: 173 case SERIAL_DATA_LITERAL: 174 case SINCE_LITERAL: 175 case THROWS_LITERAL: 176 case VERSION_LITERAL: 177 case CUSTOM_NAME: 178 return true; 179 default: 180 return false; 181 } 182 } 183 184 boolean isSameTagNames(ParserRuleContext htmlTagOpen, ParserRuleContext htmlTagClose) { 185 String openTag = htmlTagOpen.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 186 String closeTag = htmlTagClose.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); 187 System.out.println(openTag + " - " + closeTag); 188 return openTag.equals(closeTag); 189 } 190 191 public JavadocParser(TokenStream input) { 192 super(input); 193 _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); 194 } 195 public static class JavadocContext extends ParserRuleContext { 196 public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); } 197 public List<HtmlElementContext> htmlElement() { 198 return getRuleContexts(HtmlElementContext.class); 199 } 200 public HtmlElementContext htmlElement(int i) { 201 return getRuleContext(HtmlElementContext.class,i); 202 } 203 public List<HtmlCommentContext> htmlComment() { 204 return getRuleContexts(HtmlCommentContext.class); 205 } 206 public HtmlCommentContext htmlComment(int i) { 207 return getRuleContext(HtmlCommentContext.class,i); 208 } 209 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 210 public TerminalNode CDATA(int i) { 211 return getToken(JavadocParser.CDATA, i); 212 } 213 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 214 public TerminalNode NEWLINE(int i) { 215 return getToken(JavadocParser.NEWLINE, i); 216 } 217 public List<TextContext> text() { 218 return getRuleContexts(TextContext.class); 219 } 220 public TextContext text(int i) { 221 return getRuleContext(TextContext.class,i); 222 } 223 public List<JavadocInlineTagContext> javadocInlineTag() { 224 return getRuleContexts(JavadocInlineTagContext.class); 225 } 226 public JavadocInlineTagContext javadocInlineTag(int i) { 227 return getRuleContext(JavadocInlineTagContext.class,i); 228 } 229 public List<JavadocTagContext> javadocTag() { 230 return getRuleContexts(JavadocTagContext.class); 231 } 232 public JavadocTagContext javadocTag(int i) { 233 return getRuleContext(JavadocTagContext.class,i); 234 } 235 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 236 public TerminalNode LEADING_ASTERISK(int i) { 237 return getToken(JavadocParser.LEADING_ASTERISK, i); 238 } 239 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 240 public TerminalNode WS(int i) { 241 return getToken(JavadocParser.WS, i); 242 } 243 public JavadocContext(ParserRuleContext parent, int invokingState) { 244 super(parent, invokingState); 245 } 246 @Override public int getRuleIndex() { return RULE_javadoc; } 247 @Override 248 public void enterRule(ParseTreeListener listener) { 249 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadoc(this); 250 } 251 @Override 252 public void exitRule(ParseTreeListener listener) { 253 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadoc(this); 254 } 255 @Override 256 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 257 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadoc(this); 258 else return visitor.visitChildren(this); 259 } 260 } 261 262 public final JavadocContext javadoc() throws RecognitionException { 263 JavadocContext _localctx = new JavadocContext(_ctx, getState()); 264 enterRule(_localctx, 0, RULE_javadoc); 265 int _la; 266 try { 267 int _alt; 268 enterOuterAlt(_localctx, 1); 269 { 270 setState(160); 271 _errHandler.sync(this); 272 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 273 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 274 if ( _alt==1 ) { 275 { 276 setState(158); 277 _errHandler.sync(this); 278 switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { 279 case 1: 280 { 281 setState(150); 282 htmlElement(); 283 } 284 break; 285 case 2: 286 { 287 { 288 setState(151); 289 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 290 setState(152); 291 match(LEADING_ASTERISK); 292 } 293 } 294 break; 295 case 3: 296 { 297 setState(153); 298 htmlComment(); 299 } 300 break; 301 case 4: 302 { 303 setState(154); 304 match(CDATA); 305 } 306 break; 307 case 5: 308 { 309 setState(155); 310 match(NEWLINE); 311 } 312 break; 313 case 6: 314 { 315 setState(156); 316 text(); 317 } 318 break; 319 case 7: 320 { 321 setState(157); 322 javadocInlineTag(); 323 } 324 break; 325 } 326 } 327 } 328 setState(162); 329 _errHandler.sync(this); 330 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 331 } 332 setState(175); 333 _errHandler.sync(this); 334 _la = _input.LA(1); 335 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << AUTHOR_LITERAL) | (1L << DEPRECATED_LITERAL) | (1L << EXCEPTION_LITERAL) | (1L << PARAM_LITERAL) | (1L << RETURN_LITERAL) | (1L << SEE_LITERAL) | (1L << SERIAL_LITERAL) | (1L << SERIAL_FIELD_LITERAL) | (1L << SERIAL_DATA_LITERAL) | (1L << SINCE_LITERAL) | (1L << THROWS_LITERAL) | (1L << VERSION_LITERAL) | (1L << CUSTOM_NAME))) != 0)) { 336 { 337 { 338 setState(164); 339 _errHandler.sync(this); 340 _la = _input.LA(1); 341 if (_la==LEADING_ASTERISK) { 342 { 343 setState(163); 344 match(LEADING_ASTERISK); 345 } 346 } 347 348 setState(169); 349 _errHandler.sync(this); 350 _la = _input.LA(1); 351 while (_la==WS) { 352 { 353 { 354 setState(166); 355 match(WS); 356 } 357 } 358 setState(171); 359 _errHandler.sync(this); 360 _la = _input.LA(1); 361 } 362 setState(172); 363 javadocTag(); 364 } 365 } 366 setState(177); 367 _errHandler.sync(this); 368 _la = _input.LA(1); 369 } 370 setState(178); 371 match(EOF); 372 } 373 } 374 catch (RecognitionException re) { 375 _localctx.exception = re; 376 _errHandler.reportError(this, re); 377 _errHandler.recover(this, re); 378 } 379 finally { 380 exitRule(); 381 } 382 return _localctx; 383 } 384 385 public static class HtmlElementContext extends ParserRuleContext { 386 public HtmlTagContext htmlTag() { 387 return getRuleContext(HtmlTagContext.class,0); 388 } 389 public SingletonElementContext singletonElement() { 390 return getRuleContext(SingletonElementContext.class,0); 391 } 392 public ParagraphContext paragraph() { 393 return getRuleContext(ParagraphContext.class,0); 394 } 395 public LiContext li() { 396 return getRuleContext(LiContext.class,0); 397 } 398 public TrContext tr() { 399 return getRuleContext(TrContext.class,0); 400 } 401 public TdContext td() { 402 return getRuleContext(TdContext.class,0); 403 } 404 public ThContext th() { 405 return getRuleContext(ThContext.class,0); 406 } 407 public BodyContext body() { 408 return getRuleContext(BodyContext.class,0); 409 } 410 public ColgroupContext colgroup() { 411 return getRuleContext(ColgroupContext.class,0); 412 } 413 public DdContext dd() { 414 return getRuleContext(DdContext.class,0); 415 } 416 public DtContext dt() { 417 return getRuleContext(DtContext.class,0); 418 } 419 public HeadContext head() { 420 return getRuleContext(HeadContext.class,0); 421 } 422 public HtmlContext html() { 423 return getRuleContext(HtmlContext.class,0); 424 } 425 public OptionContext option() { 426 return getRuleContext(OptionContext.class,0); 427 } 428 public TbodyContext tbody() { 429 return getRuleContext(TbodyContext.class,0); 430 } 431 public TheadContext thead() { 432 return getRuleContext(TheadContext.class,0); 433 } 434 public TfootContext tfoot() { 435 return getRuleContext(TfootContext.class,0); 436 } 437 public PTagOpenContext pTagOpen() { 438 return getRuleContext(PTagOpenContext.class,0); 439 } 440 public LiTagOpenContext liTagOpen() { 441 return getRuleContext(LiTagOpenContext.class,0); 442 } 443 public TrTagOpenContext trTagOpen() { 444 return getRuleContext(TrTagOpenContext.class,0); 445 } 446 public TdTagOpenContext tdTagOpen() { 447 return getRuleContext(TdTagOpenContext.class,0); 448 } 449 public ThTagOpenContext thTagOpen() { 450 return getRuleContext(ThTagOpenContext.class,0); 451 } 452 public BodyTagOpenContext bodyTagOpen() { 453 return getRuleContext(BodyTagOpenContext.class,0); 454 } 455 public ColgroupTagOpenContext colgroupTagOpen() { 456 return getRuleContext(ColgroupTagOpenContext.class,0); 457 } 458 public DdTagOpenContext ddTagOpen() { 459 return getRuleContext(DdTagOpenContext.class,0); 460 } 461 public DtTagOpenContext dtTagOpen() { 462 return getRuleContext(DtTagOpenContext.class,0); 463 } 464 public HeadTagOpenContext headTagOpen() { 465 return getRuleContext(HeadTagOpenContext.class,0); 466 } 467 public HtmlTagOpenContext htmlTagOpen() { 468 return getRuleContext(HtmlTagOpenContext.class,0); 469 } 470 public OptionTagOpenContext optionTagOpen() { 471 return getRuleContext(OptionTagOpenContext.class,0); 472 } 473 public TbodyTagOpenContext tbodyTagOpen() { 474 return getRuleContext(TbodyTagOpenContext.class,0); 475 } 476 public TheadTagOpenContext theadTagOpen() { 477 return getRuleContext(TheadTagOpenContext.class,0); 478 } 479 public TfootTagOpenContext tfootTagOpen() { 480 return getRuleContext(TfootTagOpenContext.class,0); 481 } 482 public PTagCloseContext pTagClose() { 483 return getRuleContext(PTagCloseContext.class,0); 484 } 485 public LiTagCloseContext liTagClose() { 486 return getRuleContext(LiTagCloseContext.class,0); 487 } 488 public TrTagCloseContext trTagClose() { 489 return getRuleContext(TrTagCloseContext.class,0); 490 } 491 public TdTagCloseContext tdTagClose() { 492 return getRuleContext(TdTagCloseContext.class,0); 493 } 494 public ThTagCloseContext thTagClose() { 495 return getRuleContext(ThTagCloseContext.class,0); 496 } 497 public BodyTagCloseContext bodyTagClose() { 498 return getRuleContext(BodyTagCloseContext.class,0); 499 } 500 public ColgroupTagCloseContext colgroupTagClose() { 501 return getRuleContext(ColgroupTagCloseContext.class,0); 502 } 503 public DdTagCloseContext ddTagClose() { 504 return getRuleContext(DdTagCloseContext.class,0); 505 } 506 public DtTagCloseContext dtTagClose() { 507 return getRuleContext(DtTagCloseContext.class,0); 508 } 509 public HeadTagCloseContext headTagClose() { 510 return getRuleContext(HeadTagCloseContext.class,0); 511 } 512 public HtmlTagCloseContext htmlTagClose() { 513 return getRuleContext(HtmlTagCloseContext.class,0); 514 } 515 public OptionTagCloseContext optionTagClose() { 516 return getRuleContext(OptionTagCloseContext.class,0); 517 } 518 public TbodyTagCloseContext tbodyTagClose() { 519 return getRuleContext(TbodyTagCloseContext.class,0); 520 } 521 public TheadTagCloseContext theadTagClose() { 522 return getRuleContext(TheadTagCloseContext.class,0); 523 } 524 public TfootTagCloseContext tfootTagClose() { 525 return getRuleContext(TfootTagCloseContext.class,0); 526 } 527 public HtmlElementContext(ParserRuleContext parent, int invokingState) { 528 super(parent, invokingState); 529 } 530 @Override public int getRuleIndex() { return RULE_htmlElement; } 531 @Override 532 public void enterRule(ParseTreeListener listener) { 533 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElement(this); 534 } 535 @Override 536 public void exitRule(ParseTreeListener listener) { 537 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElement(this); 538 } 539 @Override 540 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 541 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElement(this); 542 else return visitor.visitChildren(this); 543 } 544 } 545 546 public final HtmlElementContext htmlElement() throws RecognitionException { 547 HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState()); 548 enterRule(_localctx, 2, RULE_htmlElement); 549 try { 550 setState(227); 551 _errHandler.sync(this); 552 switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { 553 case 1: 554 enterOuterAlt(_localctx, 1); 555 { 556 setState(180); 557 htmlTag(); 558 } 559 break; 560 case 2: 561 enterOuterAlt(_localctx, 2); 562 { 563 setState(181); 564 singletonElement(); 565 } 566 break; 567 case 3: 568 enterOuterAlt(_localctx, 3); 569 { 570 setState(182); 571 paragraph(); 572 } 573 break; 574 case 4: 575 enterOuterAlt(_localctx, 4); 576 { 577 setState(183); 578 li(); 579 } 580 break; 581 case 5: 582 enterOuterAlt(_localctx, 5); 583 { 584 setState(184); 585 tr(); 586 } 587 break; 588 case 6: 589 enterOuterAlt(_localctx, 6); 590 { 591 setState(185); 592 td(); 593 } 594 break; 595 case 7: 596 enterOuterAlt(_localctx, 7); 597 { 598 setState(186); 599 th(); 600 } 601 break; 602 case 8: 603 enterOuterAlt(_localctx, 8); 604 { 605 setState(187); 606 body(); 607 } 608 break; 609 case 9: 610 enterOuterAlt(_localctx, 9); 611 { 612 setState(188); 613 colgroup(); 614 } 615 break; 616 case 10: 617 enterOuterAlt(_localctx, 10); 618 { 619 setState(189); 620 dd(); 621 } 622 break; 623 case 11: 624 enterOuterAlt(_localctx, 11); 625 { 626 setState(190); 627 dt(); 628 } 629 break; 630 case 12: 631 enterOuterAlt(_localctx, 12); 632 { 633 setState(191); 634 head(); 635 } 636 break; 637 case 13: 638 enterOuterAlt(_localctx, 13); 639 { 640 setState(192); 641 html(); 642 } 643 break; 644 case 14: 645 enterOuterAlt(_localctx, 14); 646 { 647 setState(193); 648 option(); 649 } 650 break; 651 case 15: 652 enterOuterAlt(_localctx, 15); 653 { 654 setState(194); 655 tbody(); 656 } 657 break; 658 case 16: 659 enterOuterAlt(_localctx, 16); 660 { 661 setState(195); 662 thead(); 663 } 664 break; 665 case 17: 666 enterOuterAlt(_localctx, 17); 667 { 668 setState(196); 669 tfoot(); 670 } 671 break; 672 case 18: 673 enterOuterAlt(_localctx, 18); 674 { 675 setState(197); 676 pTagOpen(); 677 } 678 break; 679 case 19: 680 enterOuterAlt(_localctx, 19); 681 { 682 setState(198); 683 liTagOpen(); 684 } 685 break; 686 case 20: 687 enterOuterAlt(_localctx, 20); 688 { 689 setState(199); 690 trTagOpen(); 691 } 692 break; 693 case 21: 694 enterOuterAlt(_localctx, 21); 695 { 696 setState(200); 697 tdTagOpen(); 698 } 699 break; 700 case 22: 701 enterOuterAlt(_localctx, 22); 702 { 703 setState(201); 704 thTagOpen(); 705 } 706 break; 707 case 23: 708 enterOuterAlt(_localctx, 23); 709 { 710 setState(202); 711 bodyTagOpen(); 712 } 713 break; 714 case 24: 715 enterOuterAlt(_localctx, 24); 716 { 717 setState(203); 718 colgroupTagOpen(); 719 } 720 break; 721 case 25: 722 enterOuterAlt(_localctx, 25); 723 { 724 setState(204); 725 ddTagOpen(); 726 } 727 break; 728 case 26: 729 enterOuterAlt(_localctx, 26); 730 { 731 setState(205); 732 dtTagOpen(); 733 } 734 break; 735 case 27: 736 enterOuterAlt(_localctx, 27); 737 { 738 setState(206); 739 headTagOpen(); 740 } 741 break; 742 case 28: 743 enterOuterAlt(_localctx, 28); 744 { 745 setState(207); 746 htmlTagOpen(); 747 } 748 break; 749 case 29: 750 enterOuterAlt(_localctx, 29); 751 { 752 setState(208); 753 optionTagOpen(); 754 } 755 break; 756 case 30: 757 enterOuterAlt(_localctx, 30); 758 { 759 setState(209); 760 tbodyTagOpen(); 761 } 762 break; 763 case 31: 764 enterOuterAlt(_localctx, 31); 765 { 766 setState(210); 767 theadTagOpen(); 768 } 769 break; 770 case 32: 771 enterOuterAlt(_localctx, 32); 772 { 773 setState(211); 774 tfootTagOpen(); 775 } 776 break; 777 case 33: 778 enterOuterAlt(_localctx, 33); 779 { 780 setState(212); 781 pTagClose(); 782 } 783 break; 784 case 34: 785 enterOuterAlt(_localctx, 34); 786 { 787 setState(213); 788 liTagClose(); 789 } 790 break; 791 case 35: 792 enterOuterAlt(_localctx, 35); 793 { 794 setState(214); 795 trTagClose(); 796 } 797 break; 798 case 36: 799 enterOuterAlt(_localctx, 36); 800 { 801 setState(215); 802 tdTagClose(); 803 } 804 break; 805 case 37: 806 enterOuterAlt(_localctx, 37); 807 { 808 setState(216); 809 thTagClose(); 810 } 811 break; 812 case 38: 813 enterOuterAlt(_localctx, 38); 814 { 815 setState(217); 816 bodyTagClose(); 817 } 818 break; 819 case 39: 820 enterOuterAlt(_localctx, 39); 821 { 822 setState(218); 823 colgroupTagClose(); 824 } 825 break; 826 case 40: 827 enterOuterAlt(_localctx, 40); 828 { 829 setState(219); 830 ddTagClose(); 831 } 832 break; 833 case 41: 834 enterOuterAlt(_localctx, 41); 835 { 836 setState(220); 837 dtTagClose(); 838 } 839 break; 840 case 42: 841 enterOuterAlt(_localctx, 42); 842 { 843 setState(221); 844 headTagClose(); 845 } 846 break; 847 case 43: 848 enterOuterAlt(_localctx, 43); 849 { 850 setState(222); 851 htmlTagClose(); 852 } 853 break; 854 case 44: 855 enterOuterAlt(_localctx, 44); 856 { 857 setState(223); 858 optionTagClose(); 859 } 860 break; 861 case 45: 862 enterOuterAlt(_localctx, 45); 863 { 864 setState(224); 865 tbodyTagClose(); 866 } 867 break; 868 case 46: 869 enterOuterAlt(_localctx, 46); 870 { 871 setState(225); 872 theadTagClose(); 873 } 874 break; 875 case 47: 876 enterOuterAlt(_localctx, 47); 877 { 878 setState(226); 879 tfootTagClose(); 880 } 881 break; 882 } 883 } 884 catch (RecognitionException re) { 885 _localctx.exception = re; 886 _errHandler.reportError(this, re); 887 _errHandler.recover(this, re); 888 } 889 finally { 890 exitRule(); 891 } 892 return _localctx; 893 } 894 895 public static class HtmlElementOpenContext extends ParserRuleContext { 896 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 897 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 898 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 899 public List<AttributeContext> attribute() { 900 return getRuleContexts(AttributeContext.class); 901 } 902 public AttributeContext attribute(int i) { 903 return getRuleContext(AttributeContext.class,i); 904 } 905 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 906 public TerminalNode NEWLINE(int i) { 907 return getToken(JavadocParser.NEWLINE, i); 908 } 909 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 910 public TerminalNode LEADING_ASTERISK(int i) { 911 return getToken(JavadocParser.LEADING_ASTERISK, i); 912 } 913 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 914 public TerminalNode WS(int i) { 915 return getToken(JavadocParser.WS, i); 916 } 917 public HtmlElementOpenContext(ParserRuleContext parent, int invokingState) { 918 super(parent, invokingState); 919 } 920 @Override public int getRuleIndex() { return RULE_htmlElementOpen; } 921 @Override 922 public void enterRule(ParseTreeListener listener) { 923 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementOpen(this); 924 } 925 @Override 926 public void exitRule(ParseTreeListener listener) { 927 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementOpen(this); 928 } 929 @Override 930 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 931 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementOpen(this); 932 else return visitor.visitChildren(this); 933 } 934 } 935 936 public final HtmlElementOpenContext htmlElementOpen() throws RecognitionException { 937 HtmlElementOpenContext _localctx = new HtmlElementOpenContext(_ctx, getState()); 938 enterRule(_localctx, 4, RULE_htmlElementOpen); 939 int _la; 940 try { 941 enterOuterAlt(_localctx, 1); 942 { 943 setState(229); 944 match(OPEN); 945 setState(230); 946 match(HTML_TAG_NAME); 947 setState(237); 948 _errHandler.sync(this); 949 _la = _input.LA(1); 950 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 951 { 952 setState(235); 953 _errHandler.sync(this); 954 switch (_input.LA(1)) { 955 case HTML_TAG_NAME: 956 { 957 setState(231); 958 attribute(); 959 } 960 break; 961 case NEWLINE: 962 { 963 setState(232); 964 match(NEWLINE); 965 } 966 break; 967 case LEADING_ASTERISK: 968 { 969 setState(233); 970 match(LEADING_ASTERISK); 971 } 972 break; 973 case WS: 974 { 975 setState(234); 976 match(WS); 977 } 978 break; 979 default: 980 throw new NoViableAltException(this); 981 } 982 } 983 setState(239); 984 _errHandler.sync(this); 985 _la = _input.LA(1); 986 } 987 setState(240); 988 match(CLOSE); 989 } 990 } 991 catch (RecognitionException re) { 992 _localctx.exception = re; 993 _errHandler.reportError(this, re); 994 _errHandler.recover(this, re); 995 } 996 finally { 997 exitRule(); 998 } 999 return _localctx; 1000 } 1001 1002 public static class HtmlElementCloseContext extends ParserRuleContext { 1003 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1004 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1005 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 1006 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1007 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1008 public TerminalNode NEWLINE(int i) { 1009 return getToken(JavadocParser.NEWLINE, i); 1010 } 1011 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1012 public TerminalNode LEADING_ASTERISK(int i) { 1013 return getToken(JavadocParser.LEADING_ASTERISK, i); 1014 } 1015 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1016 public TerminalNode WS(int i) { 1017 return getToken(JavadocParser.WS, i); 1018 } 1019 public HtmlElementCloseContext(ParserRuleContext parent, int invokingState) { 1020 super(parent, invokingState); 1021 } 1022 @Override public int getRuleIndex() { return RULE_htmlElementClose; } 1023 @Override 1024 public void enterRule(ParseTreeListener listener) { 1025 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementClose(this); 1026 } 1027 @Override 1028 public void exitRule(ParseTreeListener listener) { 1029 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementClose(this); 1030 } 1031 @Override 1032 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1033 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementClose(this); 1034 else return visitor.visitChildren(this); 1035 } 1036 } 1037 1038 public final HtmlElementCloseContext htmlElementClose() throws RecognitionException { 1039 HtmlElementCloseContext _localctx = new HtmlElementCloseContext(_ctx, getState()); 1040 enterRule(_localctx, 6, RULE_htmlElementClose); 1041 int _la; 1042 try { 1043 enterOuterAlt(_localctx, 1); 1044 { 1045 setState(242); 1046 match(OPEN); 1047 setState(243); 1048 match(SLASH); 1049 setState(244); 1050 match(HTML_TAG_NAME); 1051 setState(248); 1052 _errHandler.sync(this); 1053 _la = _input.LA(1); 1054 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1055 { 1056 { 1057 setState(245); 1058 _la = _input.LA(1); 1059 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1060 _errHandler.recoverInline(this); 1061 } 1062 else { 1063 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1064 _errHandler.reportMatch(this); 1065 consume(); 1066 } 1067 } 1068 } 1069 setState(250); 1070 _errHandler.sync(this); 1071 _la = _input.LA(1); 1072 } 1073 setState(251); 1074 match(CLOSE); 1075 } 1076 } 1077 catch (RecognitionException re) { 1078 _localctx.exception = re; 1079 _errHandler.reportError(this, re); 1080 _errHandler.recover(this, re); 1081 } 1082 finally { 1083 exitRule(); 1084 } 1085 return _localctx; 1086 } 1087 1088 public static class AttributeContext extends ParserRuleContext { 1089 public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); } 1090 public TerminalNode HTML_TAG_NAME(int i) { 1091 return getToken(JavadocParser.HTML_TAG_NAME, i); 1092 } 1093 public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); } 1094 public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); } 1095 public TextContext text() { 1096 return getRuleContext(TextContext.class,0); 1097 } 1098 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1099 public TerminalNode NEWLINE(int i) { 1100 return getToken(JavadocParser.NEWLINE, i); 1101 } 1102 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1103 public TerminalNode LEADING_ASTERISK(int i) { 1104 return getToken(JavadocParser.LEADING_ASTERISK, i); 1105 } 1106 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1107 public TerminalNode WS(int i) { 1108 return getToken(JavadocParser.WS, i); 1109 } 1110 public AttributeContext(ParserRuleContext parent, int invokingState) { 1111 super(parent, invokingState); 1112 } 1113 @Override public int getRuleIndex() { return RULE_attribute; } 1114 @Override 1115 public void enterRule(ParseTreeListener listener) { 1116 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAttribute(this); 1117 } 1118 @Override 1119 public void exitRule(ParseTreeListener listener) { 1120 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAttribute(this); 1121 } 1122 @Override 1123 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1124 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAttribute(this); 1125 else return visitor.visitChildren(this); 1126 } 1127 } 1128 1129 public final AttributeContext attribute() throws RecognitionException { 1130 AttributeContext _localctx = new AttributeContext(_ctx, getState()); 1131 enterRule(_localctx, 8, RULE_attribute); 1132 int _la; 1133 try { 1134 int _alt; 1135 enterOuterAlt(_localctx, 1); 1136 { 1137 setState(253); 1138 match(HTML_TAG_NAME); 1139 setState(257); 1140 _errHandler.sync(this); 1141 _la = _input.LA(1); 1142 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1143 { 1144 { 1145 setState(254); 1146 _la = _input.LA(1); 1147 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1148 _errHandler.recoverInline(this); 1149 } 1150 else { 1151 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1152 _errHandler.reportMatch(this); 1153 consume(); 1154 } 1155 } 1156 } 1157 setState(259); 1158 _errHandler.sync(this); 1159 _la = _input.LA(1); 1160 } 1161 setState(260); 1162 match(EQUALS); 1163 setState(264); 1164 _errHandler.sync(this); 1165 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1166 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1167 if ( _alt==1 ) { 1168 { 1169 { 1170 setState(261); 1171 _la = _input.LA(1); 1172 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1173 _errHandler.recoverInline(this); 1174 } 1175 else { 1176 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1177 _errHandler.reportMatch(this); 1178 consume(); 1179 } 1180 } 1181 } 1182 } 1183 setState(266); 1184 _errHandler.sync(this); 1185 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1186 } 1187 setState(270); 1188 _errHandler.sync(this); 1189 switch (_input.LA(1)) { 1190 case ATTR_VALUE: 1191 { 1192 setState(267); 1193 match(ATTR_VALUE); 1194 } 1195 break; 1196 case WS: 1197 case CHAR: 1198 { 1199 setState(268); 1200 text(); 1201 } 1202 break; 1203 case HTML_TAG_NAME: 1204 { 1205 setState(269); 1206 match(HTML_TAG_NAME); 1207 } 1208 break; 1209 default: 1210 throw new NoViableAltException(this); 1211 } 1212 } 1213 } 1214 catch (RecognitionException re) { 1215 _localctx.exception = re; 1216 _errHandler.reportError(this, re); 1217 _errHandler.recover(this, re); 1218 } 1219 finally { 1220 exitRule(); 1221 } 1222 return _localctx; 1223 } 1224 1225 public static class HtmlTagContext extends ParserRuleContext { 1226 public HtmlElementOpenContext htmlElementOpen; 1227 public HtmlElementOpenContext htmlElementOpen() { 1228 return getRuleContext(HtmlElementOpenContext.class,0); 1229 } 1230 public HtmlElementCloseContext htmlElementClose() { 1231 return getRuleContext(HtmlElementCloseContext.class,0); 1232 } 1233 public List<HtmlElementContext> htmlElement() { 1234 return getRuleContexts(HtmlElementContext.class); 1235 } 1236 public HtmlElementContext htmlElement(int i) { 1237 return getRuleContext(HtmlElementContext.class,i); 1238 } 1239 public List<HtmlCommentContext> htmlComment() { 1240 return getRuleContexts(HtmlCommentContext.class); 1241 } 1242 public HtmlCommentContext htmlComment(int i) { 1243 return getRuleContext(HtmlCommentContext.class,i); 1244 } 1245 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1246 public TerminalNode CDATA(int i) { 1247 return getToken(JavadocParser.CDATA, i); 1248 } 1249 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1250 public TerminalNode NEWLINE(int i) { 1251 return getToken(JavadocParser.NEWLINE, i); 1252 } 1253 public List<TextContext> text() { 1254 return getRuleContexts(TextContext.class); 1255 } 1256 public TextContext text(int i) { 1257 return getRuleContext(TextContext.class,i); 1258 } 1259 public List<JavadocInlineTagContext> javadocInlineTag() { 1260 return getRuleContexts(JavadocInlineTagContext.class); 1261 } 1262 public JavadocInlineTagContext javadocInlineTag(int i) { 1263 return getRuleContext(JavadocInlineTagContext.class,i); 1264 } 1265 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1266 public TerminalNode LEADING_ASTERISK(int i) { 1267 return getToken(JavadocParser.LEADING_ASTERISK, i); 1268 } 1269 public HtmlTagContext(ParserRuleContext parent, int invokingState) { 1270 super(parent, invokingState); 1271 } 1272 @Override public int getRuleIndex() { return RULE_htmlTag; } 1273 @Override 1274 public void enterRule(ParseTreeListener listener) { 1275 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTag(this); 1276 } 1277 @Override 1278 public void exitRule(ParseTreeListener listener) { 1279 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTag(this); 1280 } 1281 @Override 1282 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1283 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTag(this); 1284 else return visitor.visitChildren(this); 1285 } 1286 } 1287 1288 public final HtmlTagContext htmlTag() throws RecognitionException { 1289 HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState()); 1290 enterRule(_localctx, 10, RULE_htmlTag); 1291 try { 1292 int _alt; 1293 setState(304); 1294 _errHandler.sync(this); 1295 switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { 1296 case 1: 1297 enterOuterAlt(_localctx, 1); 1298 { 1299 setState(272); 1300 htmlElementOpen(); 1301 setState(283); 1302 _errHandler.sync(this); 1303 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1304 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1305 if ( _alt==1 ) { 1306 { 1307 setState(281); 1308 _errHandler.sync(this); 1309 switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { 1310 case 1: 1311 { 1312 setState(273); 1313 htmlElement(); 1314 } 1315 break; 1316 case 2: 1317 { 1318 { 1319 setState(274); 1320 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1321 setState(275); 1322 match(LEADING_ASTERISK); 1323 } 1324 } 1325 break; 1326 case 3: 1327 { 1328 setState(276); 1329 htmlComment(); 1330 } 1331 break; 1332 case 4: 1333 { 1334 setState(277); 1335 match(CDATA); 1336 } 1337 break; 1338 case 5: 1339 { 1340 setState(278); 1341 match(NEWLINE); 1342 } 1343 break; 1344 case 6: 1345 { 1346 setState(279); 1347 text(); 1348 } 1349 break; 1350 case 7: 1351 { 1352 setState(280); 1353 javadocInlineTag(); 1354 } 1355 break; 1356 } 1357 } 1358 } 1359 setState(285); 1360 _errHandler.sync(this); 1361 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1362 } 1363 setState(286); 1364 htmlElementClose(); 1365 } 1366 break; 1367 case 2: 1368 enterOuterAlt(_localctx, 2); 1369 { 1370 setState(288); 1371 ((HtmlTagContext)_localctx).htmlElementOpen = htmlElementOpen(); 1372 setState(299); 1373 _errHandler.sync(this); 1374 _alt = getInterpreter().adaptivePredict(_input,15,_ctx); 1375 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1376 if ( _alt==1 ) { 1377 { 1378 setState(297); 1379 _errHandler.sync(this); 1380 switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { 1381 case 1: 1382 { 1383 setState(289); 1384 htmlElement(); 1385 } 1386 break; 1387 case 2: 1388 { 1389 { 1390 setState(290); 1391 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1392 setState(291); 1393 match(LEADING_ASTERISK); 1394 } 1395 } 1396 break; 1397 case 3: 1398 { 1399 setState(292); 1400 htmlComment(); 1401 } 1402 break; 1403 case 4: 1404 { 1405 setState(293); 1406 match(CDATA); 1407 } 1408 break; 1409 case 5: 1410 { 1411 setState(294); 1412 match(NEWLINE); 1413 } 1414 break; 1415 case 6: 1416 { 1417 setState(295); 1418 text(); 1419 } 1420 break; 1421 case 7: 1422 { 1423 setState(296); 1424 javadocInlineTag(); 1425 } 1426 break; 1427 } 1428 } 1429 } 1430 setState(301); 1431 _errHandler.sync(this); 1432 _alt = getInterpreter().adaptivePredict(_input,15,_ctx); 1433 } 1434 notifyErrorListeners(((HtmlTagContext)_localctx).htmlElementOpen.getToken(HTML_TAG_NAME, 0).getSymbol() 1435 , "javadoc.missed.html.close", null); 1436 } 1437 break; 1438 } 1439 } 1440 catch (RecognitionException re) { 1441 _localctx.exception = re; 1442 _errHandler.reportError(this, re); 1443 _errHandler.recover(this, re); 1444 } 1445 finally { 1446 exitRule(); 1447 } 1448 return _localctx; 1449 } 1450 1451 public static class PTagOpenContext extends ParserRuleContext { 1452 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1453 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1454 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1455 public List<AttributeContext> attribute() { 1456 return getRuleContexts(AttributeContext.class); 1457 } 1458 public AttributeContext attribute(int i) { 1459 return getRuleContext(AttributeContext.class,i); 1460 } 1461 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1462 public TerminalNode NEWLINE(int i) { 1463 return getToken(JavadocParser.NEWLINE, i); 1464 } 1465 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1466 public TerminalNode LEADING_ASTERISK(int i) { 1467 return getToken(JavadocParser.LEADING_ASTERISK, i); 1468 } 1469 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1470 public TerminalNode WS(int i) { 1471 return getToken(JavadocParser.WS, i); 1472 } 1473 public PTagOpenContext(ParserRuleContext parent, int invokingState) { 1474 super(parent, invokingState); 1475 } 1476 @Override public int getRuleIndex() { return RULE_pTagOpen; } 1477 @Override 1478 public void enterRule(ParseTreeListener listener) { 1479 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagOpen(this); 1480 } 1481 @Override 1482 public void exitRule(ParseTreeListener listener) { 1483 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagOpen(this); 1484 } 1485 @Override 1486 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1487 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagOpen(this); 1488 else return visitor.visitChildren(this); 1489 } 1490 } 1491 1492 public final PTagOpenContext pTagOpen() throws RecognitionException { 1493 PTagOpenContext _localctx = new PTagOpenContext(_ctx, getState()); 1494 enterRule(_localctx, 12, RULE_pTagOpen); 1495 int _la; 1496 try { 1497 enterOuterAlt(_localctx, 1); 1498 { 1499 setState(306); 1500 match(OPEN); 1501 setState(307); 1502 match(P_HTML_TAG_NAME); 1503 setState(314); 1504 _errHandler.sync(this); 1505 _la = _input.LA(1); 1506 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 1507 { 1508 setState(312); 1509 _errHandler.sync(this); 1510 switch (_input.LA(1)) { 1511 case HTML_TAG_NAME: 1512 { 1513 setState(308); 1514 attribute(); 1515 } 1516 break; 1517 case NEWLINE: 1518 { 1519 setState(309); 1520 match(NEWLINE); 1521 } 1522 break; 1523 case LEADING_ASTERISK: 1524 { 1525 setState(310); 1526 match(LEADING_ASTERISK); 1527 } 1528 break; 1529 case WS: 1530 { 1531 setState(311); 1532 match(WS); 1533 } 1534 break; 1535 default: 1536 throw new NoViableAltException(this); 1537 } 1538 } 1539 setState(316); 1540 _errHandler.sync(this); 1541 _la = _input.LA(1); 1542 } 1543 setState(317); 1544 match(CLOSE); 1545 } 1546 } 1547 catch (RecognitionException re) { 1548 _localctx.exception = re; 1549 _errHandler.reportError(this, re); 1550 _errHandler.recover(this, re); 1551 } 1552 finally { 1553 exitRule(); 1554 } 1555 return _localctx; 1556 } 1557 1558 public static class PTagCloseContext extends ParserRuleContext { 1559 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1560 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1561 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1562 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1563 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1564 public TerminalNode NEWLINE(int i) { 1565 return getToken(JavadocParser.NEWLINE, i); 1566 } 1567 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1568 public TerminalNode LEADING_ASTERISK(int i) { 1569 return getToken(JavadocParser.LEADING_ASTERISK, i); 1570 } 1571 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1572 public TerminalNode WS(int i) { 1573 return getToken(JavadocParser.WS, i); 1574 } 1575 public PTagCloseContext(ParserRuleContext parent, int invokingState) { 1576 super(parent, invokingState); 1577 } 1578 @Override public int getRuleIndex() { return RULE_pTagClose; } 1579 @Override 1580 public void enterRule(ParseTreeListener listener) { 1581 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagClose(this); 1582 } 1583 @Override 1584 public void exitRule(ParseTreeListener listener) { 1585 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagClose(this); 1586 } 1587 @Override 1588 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1589 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagClose(this); 1590 else return visitor.visitChildren(this); 1591 } 1592 } 1593 1594 public final PTagCloseContext pTagClose() throws RecognitionException { 1595 PTagCloseContext _localctx = new PTagCloseContext(_ctx, getState()); 1596 enterRule(_localctx, 14, RULE_pTagClose); 1597 int _la; 1598 try { 1599 enterOuterAlt(_localctx, 1); 1600 { 1601 setState(319); 1602 match(OPEN); 1603 setState(320); 1604 match(SLASH); 1605 setState(321); 1606 match(P_HTML_TAG_NAME); 1607 setState(325); 1608 _errHandler.sync(this); 1609 _la = _input.LA(1); 1610 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1611 { 1612 { 1613 setState(322); 1614 _la = _input.LA(1); 1615 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1616 _errHandler.recoverInline(this); 1617 } 1618 else { 1619 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 1620 _errHandler.reportMatch(this); 1621 consume(); 1622 } 1623 } 1624 } 1625 setState(327); 1626 _errHandler.sync(this); 1627 _la = _input.LA(1); 1628 } 1629 setState(328); 1630 match(CLOSE); 1631 } 1632 } 1633 catch (RecognitionException re) { 1634 _localctx.exception = re; 1635 _errHandler.reportError(this, re); 1636 _errHandler.recover(this, re); 1637 } 1638 finally { 1639 exitRule(); 1640 } 1641 return _localctx; 1642 } 1643 1644 public static class ParagraphContext extends ParserRuleContext { 1645 public PTagOpenContext pTagOpen() { 1646 return getRuleContext(PTagOpenContext.class,0); 1647 } 1648 public PTagCloseContext pTagClose() { 1649 return getRuleContext(PTagCloseContext.class,0); 1650 } 1651 public List<HtmlTagContext> htmlTag() { 1652 return getRuleContexts(HtmlTagContext.class); 1653 } 1654 public HtmlTagContext htmlTag(int i) { 1655 return getRuleContext(HtmlTagContext.class,i); 1656 } 1657 public List<SingletonTagContext> singletonTag() { 1658 return getRuleContexts(SingletonTagContext.class); 1659 } 1660 public SingletonTagContext singletonTag(int i) { 1661 return getRuleContext(SingletonTagContext.class,i); 1662 } 1663 public List<LiContext> li() { 1664 return getRuleContexts(LiContext.class); 1665 } 1666 public LiContext li(int i) { 1667 return getRuleContext(LiContext.class,i); 1668 } 1669 public List<TrContext> tr() { 1670 return getRuleContexts(TrContext.class); 1671 } 1672 public TrContext tr(int i) { 1673 return getRuleContext(TrContext.class,i); 1674 } 1675 public List<TdContext> td() { 1676 return getRuleContexts(TdContext.class); 1677 } 1678 public TdContext td(int i) { 1679 return getRuleContext(TdContext.class,i); 1680 } 1681 public List<ThContext> th() { 1682 return getRuleContexts(ThContext.class); 1683 } 1684 public ThContext th(int i) { 1685 return getRuleContext(ThContext.class,i); 1686 } 1687 public List<BodyContext> body() { 1688 return getRuleContexts(BodyContext.class); 1689 } 1690 public BodyContext body(int i) { 1691 return getRuleContext(BodyContext.class,i); 1692 } 1693 public List<ColgroupContext> colgroup() { 1694 return getRuleContexts(ColgroupContext.class); 1695 } 1696 public ColgroupContext colgroup(int i) { 1697 return getRuleContext(ColgroupContext.class,i); 1698 } 1699 public List<DdContext> dd() { 1700 return getRuleContexts(DdContext.class); 1701 } 1702 public DdContext dd(int i) { 1703 return getRuleContext(DdContext.class,i); 1704 } 1705 public List<DtContext> dt() { 1706 return getRuleContexts(DtContext.class); 1707 } 1708 public DtContext dt(int i) { 1709 return getRuleContext(DtContext.class,i); 1710 } 1711 public List<HeadContext> head() { 1712 return getRuleContexts(HeadContext.class); 1713 } 1714 public HeadContext head(int i) { 1715 return getRuleContext(HeadContext.class,i); 1716 } 1717 public List<HtmlContext> html() { 1718 return getRuleContexts(HtmlContext.class); 1719 } 1720 public HtmlContext html(int i) { 1721 return getRuleContext(HtmlContext.class,i); 1722 } 1723 public List<OptionContext> option() { 1724 return getRuleContexts(OptionContext.class); 1725 } 1726 public OptionContext option(int i) { 1727 return getRuleContext(OptionContext.class,i); 1728 } 1729 public List<TbodyContext> tbody() { 1730 return getRuleContexts(TbodyContext.class); 1731 } 1732 public TbodyContext tbody(int i) { 1733 return getRuleContext(TbodyContext.class,i); 1734 } 1735 public List<TheadContext> thead() { 1736 return getRuleContexts(TheadContext.class); 1737 } 1738 public TheadContext thead(int i) { 1739 return getRuleContext(TheadContext.class,i); 1740 } 1741 public List<TfootContext> tfoot() { 1742 return getRuleContexts(TfootContext.class); 1743 } 1744 public TfootContext tfoot(int i) { 1745 return getRuleContext(TfootContext.class,i); 1746 } 1747 public List<LiTagOpenContext> liTagOpen() { 1748 return getRuleContexts(LiTagOpenContext.class); 1749 } 1750 public LiTagOpenContext liTagOpen(int i) { 1751 return getRuleContext(LiTagOpenContext.class,i); 1752 } 1753 public List<TrTagOpenContext> trTagOpen() { 1754 return getRuleContexts(TrTagOpenContext.class); 1755 } 1756 public TrTagOpenContext trTagOpen(int i) { 1757 return getRuleContext(TrTagOpenContext.class,i); 1758 } 1759 public List<TdTagOpenContext> tdTagOpen() { 1760 return getRuleContexts(TdTagOpenContext.class); 1761 } 1762 public TdTagOpenContext tdTagOpen(int i) { 1763 return getRuleContext(TdTagOpenContext.class,i); 1764 } 1765 public List<ThTagOpenContext> thTagOpen() { 1766 return getRuleContexts(ThTagOpenContext.class); 1767 } 1768 public ThTagOpenContext thTagOpen(int i) { 1769 return getRuleContext(ThTagOpenContext.class,i); 1770 } 1771 public List<BodyTagOpenContext> bodyTagOpen() { 1772 return getRuleContexts(BodyTagOpenContext.class); 1773 } 1774 public BodyTagOpenContext bodyTagOpen(int i) { 1775 return getRuleContext(BodyTagOpenContext.class,i); 1776 } 1777 public List<ColgroupTagOpenContext> colgroupTagOpen() { 1778 return getRuleContexts(ColgroupTagOpenContext.class); 1779 } 1780 public ColgroupTagOpenContext colgroupTagOpen(int i) { 1781 return getRuleContext(ColgroupTagOpenContext.class,i); 1782 } 1783 public List<DdTagOpenContext> ddTagOpen() { 1784 return getRuleContexts(DdTagOpenContext.class); 1785 } 1786 public DdTagOpenContext ddTagOpen(int i) { 1787 return getRuleContext(DdTagOpenContext.class,i); 1788 } 1789 public List<DtTagOpenContext> dtTagOpen() { 1790 return getRuleContexts(DtTagOpenContext.class); 1791 } 1792 public DtTagOpenContext dtTagOpen(int i) { 1793 return getRuleContext(DtTagOpenContext.class,i); 1794 } 1795 public List<HeadTagOpenContext> headTagOpen() { 1796 return getRuleContexts(HeadTagOpenContext.class); 1797 } 1798 public HeadTagOpenContext headTagOpen(int i) { 1799 return getRuleContext(HeadTagOpenContext.class,i); 1800 } 1801 public List<HtmlTagOpenContext> htmlTagOpen() { 1802 return getRuleContexts(HtmlTagOpenContext.class); 1803 } 1804 public HtmlTagOpenContext htmlTagOpen(int i) { 1805 return getRuleContext(HtmlTagOpenContext.class,i); 1806 } 1807 public List<OptionTagOpenContext> optionTagOpen() { 1808 return getRuleContexts(OptionTagOpenContext.class); 1809 } 1810 public OptionTagOpenContext optionTagOpen(int i) { 1811 return getRuleContext(OptionTagOpenContext.class,i); 1812 } 1813 public List<TbodyTagOpenContext> tbodyTagOpen() { 1814 return getRuleContexts(TbodyTagOpenContext.class); 1815 } 1816 public TbodyTagOpenContext tbodyTagOpen(int i) { 1817 return getRuleContext(TbodyTagOpenContext.class,i); 1818 } 1819 public List<TheadTagOpenContext> theadTagOpen() { 1820 return getRuleContexts(TheadTagOpenContext.class); 1821 } 1822 public TheadTagOpenContext theadTagOpen(int i) { 1823 return getRuleContext(TheadTagOpenContext.class,i); 1824 } 1825 public List<TfootTagOpenContext> tfootTagOpen() { 1826 return getRuleContexts(TfootTagOpenContext.class); 1827 } 1828 public TfootTagOpenContext tfootTagOpen(int i) { 1829 return getRuleContext(TfootTagOpenContext.class,i); 1830 } 1831 public List<HtmlCommentContext> htmlComment() { 1832 return getRuleContexts(HtmlCommentContext.class); 1833 } 1834 public HtmlCommentContext htmlComment(int i) { 1835 return getRuleContext(HtmlCommentContext.class,i); 1836 } 1837 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1838 public TerminalNode CDATA(int i) { 1839 return getToken(JavadocParser.CDATA, i); 1840 } 1841 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1842 public TerminalNode NEWLINE(int i) { 1843 return getToken(JavadocParser.NEWLINE, i); 1844 } 1845 public List<TextContext> text() { 1846 return getRuleContexts(TextContext.class); 1847 } 1848 public TextContext text(int i) { 1849 return getRuleContext(TextContext.class,i); 1850 } 1851 public List<JavadocInlineTagContext> javadocInlineTag() { 1852 return getRuleContexts(JavadocInlineTagContext.class); 1853 } 1854 public JavadocInlineTagContext javadocInlineTag(int i) { 1855 return getRuleContext(JavadocInlineTagContext.class,i); 1856 } 1857 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1858 public TerminalNode LEADING_ASTERISK(int i) { 1859 return getToken(JavadocParser.LEADING_ASTERISK, i); 1860 } 1861 public ParagraphContext(ParserRuleContext parent, int invokingState) { 1862 super(parent, invokingState); 1863 } 1864 @Override public int getRuleIndex() { return RULE_paragraph; } 1865 @Override 1866 public void enterRule(ParseTreeListener listener) { 1867 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParagraph(this); 1868 } 1869 @Override 1870 public void exitRule(ParseTreeListener listener) { 1871 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParagraph(this); 1872 } 1873 @Override 1874 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1875 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParagraph(this); 1876 else return visitor.visitChildren(this); 1877 } 1878 } 1879 1880 public final ParagraphContext paragraph() throws RecognitionException { 1881 ParagraphContext _localctx = new ParagraphContext(_ctx, getState()); 1882 enterRule(_localctx, 16, RULE_paragraph); 1883 try { 1884 int _alt; 1885 enterOuterAlt(_localctx, 1); 1886 { 1887 setState(330); 1888 pTagOpen(); 1889 setState(370); 1890 _errHandler.sync(this); 1891 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 1892 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1893 if ( _alt==1 ) { 1894 { 1895 setState(368); 1896 _errHandler.sync(this); 1897 switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) { 1898 case 1: 1899 { 1900 setState(331); 1901 htmlTag(); 1902 } 1903 break; 1904 case 2: 1905 { 1906 setState(332); 1907 singletonTag(); 1908 } 1909 break; 1910 case 3: 1911 { 1912 setState(333); 1913 li(); 1914 } 1915 break; 1916 case 4: 1917 { 1918 setState(334); 1919 tr(); 1920 } 1921 break; 1922 case 5: 1923 { 1924 setState(335); 1925 td(); 1926 } 1927 break; 1928 case 6: 1929 { 1930 setState(336); 1931 th(); 1932 } 1933 break; 1934 case 7: 1935 { 1936 setState(337); 1937 body(); 1938 } 1939 break; 1940 case 8: 1941 { 1942 setState(338); 1943 colgroup(); 1944 } 1945 break; 1946 case 9: 1947 { 1948 setState(339); 1949 dd(); 1950 } 1951 break; 1952 case 10: 1953 { 1954 setState(340); 1955 dt(); 1956 } 1957 break; 1958 case 11: 1959 { 1960 setState(341); 1961 head(); 1962 } 1963 break; 1964 case 12: 1965 { 1966 setState(342); 1967 html(); 1968 } 1969 break; 1970 case 13: 1971 { 1972 setState(343); 1973 option(); 1974 } 1975 break; 1976 case 14: 1977 { 1978 setState(344); 1979 tbody(); 1980 } 1981 break; 1982 case 15: 1983 { 1984 setState(345); 1985 thead(); 1986 } 1987 break; 1988 case 16: 1989 { 1990 setState(346); 1991 tfoot(); 1992 } 1993 break; 1994 case 17: 1995 { 1996 setState(347); 1997 liTagOpen(); 1998 } 1999 break; 2000 case 18: 2001 { 2002 setState(348); 2003 trTagOpen(); 2004 } 2005 break; 2006 case 19: 2007 { 2008 setState(349); 2009 tdTagOpen(); 2010 } 2011 break; 2012 case 20: 2013 { 2014 setState(350); 2015 thTagOpen(); 2016 } 2017 break; 2018 case 21: 2019 { 2020 setState(351); 2021 bodyTagOpen(); 2022 } 2023 break; 2024 case 22: 2025 { 2026 setState(352); 2027 colgroupTagOpen(); 2028 } 2029 break; 2030 case 23: 2031 { 2032 setState(353); 2033 ddTagOpen(); 2034 } 2035 break; 2036 case 24: 2037 { 2038 setState(354); 2039 dtTagOpen(); 2040 } 2041 break; 2042 case 25: 2043 { 2044 setState(355); 2045 headTagOpen(); 2046 } 2047 break; 2048 case 26: 2049 { 2050 setState(356); 2051 htmlTagOpen(); 2052 } 2053 break; 2054 case 27: 2055 { 2056 setState(357); 2057 optionTagOpen(); 2058 } 2059 break; 2060 case 28: 2061 { 2062 setState(358); 2063 tbodyTagOpen(); 2064 } 2065 break; 2066 case 29: 2067 { 2068 setState(359); 2069 theadTagOpen(); 2070 } 2071 break; 2072 case 30: 2073 { 2074 setState(360); 2075 tfootTagOpen(); 2076 } 2077 break; 2078 case 31: 2079 { 2080 { 2081 setState(361); 2082 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2083 setState(362); 2084 match(LEADING_ASTERISK); 2085 } 2086 } 2087 break; 2088 case 32: 2089 { 2090 setState(363); 2091 htmlComment(); 2092 } 2093 break; 2094 case 33: 2095 { 2096 setState(364); 2097 match(CDATA); 2098 } 2099 break; 2100 case 34: 2101 { 2102 setState(365); 2103 match(NEWLINE); 2104 } 2105 break; 2106 case 35: 2107 { 2108 setState(366); 2109 text(); 2110 } 2111 break; 2112 case 36: 2113 { 2114 setState(367); 2115 javadocInlineTag(); 2116 } 2117 break; 2118 } 2119 } 2120 } 2121 setState(372); 2122 _errHandler.sync(this); 2123 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 2124 } 2125 setState(373); 2126 pTagClose(); 2127 } 2128 } 2129 catch (RecognitionException re) { 2130 _localctx.exception = re; 2131 _errHandler.reportError(this, re); 2132 _errHandler.recover(this, re); 2133 } 2134 finally { 2135 exitRule(); 2136 } 2137 return _localctx; 2138 } 2139 2140 public static class LiTagOpenContext extends ParserRuleContext { 2141 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2142 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2143 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2144 public List<AttributeContext> attribute() { 2145 return getRuleContexts(AttributeContext.class); 2146 } 2147 public AttributeContext attribute(int i) { 2148 return getRuleContext(AttributeContext.class,i); 2149 } 2150 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2151 public TerminalNode NEWLINE(int i) { 2152 return getToken(JavadocParser.NEWLINE, i); 2153 } 2154 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2155 public TerminalNode LEADING_ASTERISK(int i) { 2156 return getToken(JavadocParser.LEADING_ASTERISK, i); 2157 } 2158 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2159 public TerminalNode WS(int i) { 2160 return getToken(JavadocParser.WS, i); 2161 } 2162 public LiTagOpenContext(ParserRuleContext parent, int invokingState) { 2163 super(parent, invokingState); 2164 } 2165 @Override public int getRuleIndex() { return RULE_liTagOpen; } 2166 @Override 2167 public void enterRule(ParseTreeListener listener) { 2168 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagOpen(this); 2169 } 2170 @Override 2171 public void exitRule(ParseTreeListener listener) { 2172 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagOpen(this); 2173 } 2174 @Override 2175 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2176 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagOpen(this); 2177 else return visitor.visitChildren(this); 2178 } 2179 } 2180 2181 public final LiTagOpenContext liTagOpen() throws RecognitionException { 2182 LiTagOpenContext _localctx = new LiTagOpenContext(_ctx, getState()); 2183 enterRule(_localctx, 18, RULE_liTagOpen); 2184 int _la; 2185 try { 2186 enterOuterAlt(_localctx, 1); 2187 { 2188 setState(375); 2189 match(OPEN); 2190 setState(376); 2191 match(LI_HTML_TAG_NAME); 2192 setState(383); 2193 _errHandler.sync(this); 2194 _la = _input.LA(1); 2195 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2196 { 2197 setState(381); 2198 _errHandler.sync(this); 2199 switch (_input.LA(1)) { 2200 case HTML_TAG_NAME: 2201 { 2202 setState(377); 2203 attribute(); 2204 } 2205 break; 2206 case NEWLINE: 2207 { 2208 setState(378); 2209 match(NEWLINE); 2210 } 2211 break; 2212 case LEADING_ASTERISK: 2213 { 2214 setState(379); 2215 match(LEADING_ASTERISK); 2216 } 2217 break; 2218 case WS: 2219 { 2220 setState(380); 2221 match(WS); 2222 } 2223 break; 2224 default: 2225 throw new NoViableAltException(this); 2226 } 2227 } 2228 setState(385); 2229 _errHandler.sync(this); 2230 _la = _input.LA(1); 2231 } 2232 setState(386); 2233 match(CLOSE); 2234 } 2235 } 2236 catch (RecognitionException re) { 2237 _localctx.exception = re; 2238 _errHandler.reportError(this, re); 2239 _errHandler.recover(this, re); 2240 } 2241 finally { 2242 exitRule(); 2243 } 2244 return _localctx; 2245 } 2246 2247 public static class LiTagCloseContext extends ParserRuleContext { 2248 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2249 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2250 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2251 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2252 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2253 public TerminalNode NEWLINE(int i) { 2254 return getToken(JavadocParser.NEWLINE, i); 2255 } 2256 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2257 public TerminalNode LEADING_ASTERISK(int i) { 2258 return getToken(JavadocParser.LEADING_ASTERISK, i); 2259 } 2260 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2261 public TerminalNode WS(int i) { 2262 return getToken(JavadocParser.WS, i); 2263 } 2264 public LiTagCloseContext(ParserRuleContext parent, int invokingState) { 2265 super(parent, invokingState); 2266 } 2267 @Override public int getRuleIndex() { return RULE_liTagClose; } 2268 @Override 2269 public void enterRule(ParseTreeListener listener) { 2270 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagClose(this); 2271 } 2272 @Override 2273 public void exitRule(ParseTreeListener listener) { 2274 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagClose(this); 2275 } 2276 @Override 2277 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2278 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagClose(this); 2279 else return visitor.visitChildren(this); 2280 } 2281 } 2282 2283 public final LiTagCloseContext liTagClose() throws RecognitionException { 2284 LiTagCloseContext _localctx = new LiTagCloseContext(_ctx, getState()); 2285 enterRule(_localctx, 20, RULE_liTagClose); 2286 int _la; 2287 try { 2288 enterOuterAlt(_localctx, 1); 2289 { 2290 setState(388); 2291 match(OPEN); 2292 setState(389); 2293 match(SLASH); 2294 setState(390); 2295 match(LI_HTML_TAG_NAME); 2296 setState(394); 2297 _errHandler.sync(this); 2298 _la = _input.LA(1); 2299 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2300 { 2301 { 2302 setState(391); 2303 _la = _input.LA(1); 2304 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2305 _errHandler.recoverInline(this); 2306 } 2307 else { 2308 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 2309 _errHandler.reportMatch(this); 2310 consume(); 2311 } 2312 } 2313 } 2314 setState(396); 2315 _errHandler.sync(this); 2316 _la = _input.LA(1); 2317 } 2318 setState(397); 2319 match(CLOSE); 2320 } 2321 } 2322 catch (RecognitionException re) { 2323 _localctx.exception = re; 2324 _errHandler.reportError(this, re); 2325 _errHandler.recover(this, re); 2326 } 2327 finally { 2328 exitRule(); 2329 } 2330 return _localctx; 2331 } 2332 2333 public static class LiContext extends ParserRuleContext { 2334 public LiTagOpenContext liTagOpen() { 2335 return getRuleContext(LiTagOpenContext.class,0); 2336 } 2337 public LiTagCloseContext liTagClose() { 2338 return getRuleContext(LiTagCloseContext.class,0); 2339 } 2340 public List<HtmlTagContext> htmlTag() { 2341 return getRuleContexts(HtmlTagContext.class); 2342 } 2343 public HtmlTagContext htmlTag(int i) { 2344 return getRuleContext(HtmlTagContext.class,i); 2345 } 2346 public List<SingletonTagContext> singletonTag() { 2347 return getRuleContexts(SingletonTagContext.class); 2348 } 2349 public SingletonTagContext singletonTag(int i) { 2350 return getRuleContext(SingletonTagContext.class,i); 2351 } 2352 public List<ParagraphContext> paragraph() { 2353 return getRuleContexts(ParagraphContext.class); 2354 } 2355 public ParagraphContext paragraph(int i) { 2356 return getRuleContext(ParagraphContext.class,i); 2357 } 2358 public List<TrContext> tr() { 2359 return getRuleContexts(TrContext.class); 2360 } 2361 public TrContext tr(int i) { 2362 return getRuleContext(TrContext.class,i); 2363 } 2364 public List<TdContext> td() { 2365 return getRuleContexts(TdContext.class); 2366 } 2367 public TdContext td(int i) { 2368 return getRuleContext(TdContext.class,i); 2369 } 2370 public List<ThContext> th() { 2371 return getRuleContexts(ThContext.class); 2372 } 2373 public ThContext th(int i) { 2374 return getRuleContext(ThContext.class,i); 2375 } 2376 public List<BodyContext> body() { 2377 return getRuleContexts(BodyContext.class); 2378 } 2379 public BodyContext body(int i) { 2380 return getRuleContext(BodyContext.class,i); 2381 } 2382 public List<ColgroupContext> colgroup() { 2383 return getRuleContexts(ColgroupContext.class); 2384 } 2385 public ColgroupContext colgroup(int i) { 2386 return getRuleContext(ColgroupContext.class,i); 2387 } 2388 public List<DdContext> dd() { 2389 return getRuleContexts(DdContext.class); 2390 } 2391 public DdContext dd(int i) { 2392 return getRuleContext(DdContext.class,i); 2393 } 2394 public List<DtContext> dt() { 2395 return getRuleContexts(DtContext.class); 2396 } 2397 public DtContext dt(int i) { 2398 return getRuleContext(DtContext.class,i); 2399 } 2400 public List<HeadContext> head() { 2401 return getRuleContexts(HeadContext.class); 2402 } 2403 public HeadContext head(int i) { 2404 return getRuleContext(HeadContext.class,i); 2405 } 2406 public List<HtmlContext> html() { 2407 return getRuleContexts(HtmlContext.class); 2408 } 2409 public HtmlContext html(int i) { 2410 return getRuleContext(HtmlContext.class,i); 2411 } 2412 public List<OptionContext> option() { 2413 return getRuleContexts(OptionContext.class); 2414 } 2415 public OptionContext option(int i) { 2416 return getRuleContext(OptionContext.class,i); 2417 } 2418 public List<TbodyContext> tbody() { 2419 return getRuleContexts(TbodyContext.class); 2420 } 2421 public TbodyContext tbody(int i) { 2422 return getRuleContext(TbodyContext.class,i); 2423 } 2424 public List<TheadContext> thead() { 2425 return getRuleContexts(TheadContext.class); 2426 } 2427 public TheadContext thead(int i) { 2428 return getRuleContext(TheadContext.class,i); 2429 } 2430 public List<TfootContext> tfoot() { 2431 return getRuleContexts(TfootContext.class); 2432 } 2433 public TfootContext tfoot(int i) { 2434 return getRuleContext(TfootContext.class,i); 2435 } 2436 public List<PTagOpenContext> pTagOpen() { 2437 return getRuleContexts(PTagOpenContext.class); 2438 } 2439 public PTagOpenContext pTagOpen(int i) { 2440 return getRuleContext(PTagOpenContext.class,i); 2441 } 2442 public List<TrTagOpenContext> trTagOpen() { 2443 return getRuleContexts(TrTagOpenContext.class); 2444 } 2445 public TrTagOpenContext trTagOpen(int i) { 2446 return getRuleContext(TrTagOpenContext.class,i); 2447 } 2448 public List<TdTagOpenContext> tdTagOpen() { 2449 return getRuleContexts(TdTagOpenContext.class); 2450 } 2451 public TdTagOpenContext tdTagOpen(int i) { 2452 return getRuleContext(TdTagOpenContext.class,i); 2453 } 2454 public List<ThTagOpenContext> thTagOpen() { 2455 return getRuleContexts(ThTagOpenContext.class); 2456 } 2457 public ThTagOpenContext thTagOpen(int i) { 2458 return getRuleContext(ThTagOpenContext.class,i); 2459 } 2460 public List<BodyTagOpenContext> bodyTagOpen() { 2461 return getRuleContexts(BodyTagOpenContext.class); 2462 } 2463 public BodyTagOpenContext bodyTagOpen(int i) { 2464 return getRuleContext(BodyTagOpenContext.class,i); 2465 } 2466 public List<ColgroupTagOpenContext> colgroupTagOpen() { 2467 return getRuleContexts(ColgroupTagOpenContext.class); 2468 } 2469 public ColgroupTagOpenContext colgroupTagOpen(int i) { 2470 return getRuleContext(ColgroupTagOpenContext.class,i); 2471 } 2472 public List<DdTagOpenContext> ddTagOpen() { 2473 return getRuleContexts(DdTagOpenContext.class); 2474 } 2475 public DdTagOpenContext ddTagOpen(int i) { 2476 return getRuleContext(DdTagOpenContext.class,i); 2477 } 2478 public List<DtTagOpenContext> dtTagOpen() { 2479 return getRuleContexts(DtTagOpenContext.class); 2480 } 2481 public DtTagOpenContext dtTagOpen(int i) { 2482 return getRuleContext(DtTagOpenContext.class,i); 2483 } 2484 public List<HeadTagOpenContext> headTagOpen() { 2485 return getRuleContexts(HeadTagOpenContext.class); 2486 } 2487 public HeadTagOpenContext headTagOpen(int i) { 2488 return getRuleContext(HeadTagOpenContext.class,i); 2489 } 2490 public List<HtmlTagOpenContext> htmlTagOpen() { 2491 return getRuleContexts(HtmlTagOpenContext.class); 2492 } 2493 public HtmlTagOpenContext htmlTagOpen(int i) { 2494 return getRuleContext(HtmlTagOpenContext.class,i); 2495 } 2496 public List<OptionTagOpenContext> optionTagOpen() { 2497 return getRuleContexts(OptionTagOpenContext.class); 2498 } 2499 public OptionTagOpenContext optionTagOpen(int i) { 2500 return getRuleContext(OptionTagOpenContext.class,i); 2501 } 2502 public List<TbodyTagOpenContext> tbodyTagOpen() { 2503 return getRuleContexts(TbodyTagOpenContext.class); 2504 } 2505 public TbodyTagOpenContext tbodyTagOpen(int i) { 2506 return getRuleContext(TbodyTagOpenContext.class,i); 2507 } 2508 public List<TheadTagOpenContext> theadTagOpen() { 2509 return getRuleContexts(TheadTagOpenContext.class); 2510 } 2511 public TheadTagOpenContext theadTagOpen(int i) { 2512 return getRuleContext(TheadTagOpenContext.class,i); 2513 } 2514 public List<TfootTagOpenContext> tfootTagOpen() { 2515 return getRuleContexts(TfootTagOpenContext.class); 2516 } 2517 public TfootTagOpenContext tfootTagOpen(int i) { 2518 return getRuleContext(TfootTagOpenContext.class,i); 2519 } 2520 public List<HtmlCommentContext> htmlComment() { 2521 return getRuleContexts(HtmlCommentContext.class); 2522 } 2523 public HtmlCommentContext htmlComment(int i) { 2524 return getRuleContext(HtmlCommentContext.class,i); 2525 } 2526 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 2527 public TerminalNode CDATA(int i) { 2528 return getToken(JavadocParser.CDATA, i); 2529 } 2530 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2531 public TerminalNode NEWLINE(int i) { 2532 return getToken(JavadocParser.NEWLINE, i); 2533 } 2534 public List<TextContext> text() { 2535 return getRuleContexts(TextContext.class); 2536 } 2537 public TextContext text(int i) { 2538 return getRuleContext(TextContext.class,i); 2539 } 2540 public List<JavadocInlineTagContext> javadocInlineTag() { 2541 return getRuleContexts(JavadocInlineTagContext.class); 2542 } 2543 public JavadocInlineTagContext javadocInlineTag(int i) { 2544 return getRuleContext(JavadocInlineTagContext.class,i); 2545 } 2546 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2547 public TerminalNode LEADING_ASTERISK(int i) { 2548 return getToken(JavadocParser.LEADING_ASTERISK, i); 2549 } 2550 public LiContext(ParserRuleContext parent, int invokingState) { 2551 super(parent, invokingState); 2552 } 2553 @Override public int getRuleIndex() { return RULE_li; } 2554 @Override 2555 public void enterRule(ParseTreeListener listener) { 2556 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLi(this); 2557 } 2558 @Override 2559 public void exitRule(ParseTreeListener listener) { 2560 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLi(this); 2561 } 2562 @Override 2563 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2564 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLi(this); 2565 else return visitor.visitChildren(this); 2566 } 2567 } 2568 2569 public final LiContext li() throws RecognitionException { 2570 LiContext _localctx = new LiContext(_ctx, getState()); 2571 enterRule(_localctx, 22, RULE_li); 2572 try { 2573 int _alt; 2574 enterOuterAlt(_localctx, 1); 2575 { 2576 setState(399); 2577 liTagOpen(); 2578 setState(439); 2579 _errHandler.sync(this); 2580 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 2581 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 2582 if ( _alt==1 ) { 2583 { 2584 setState(437); 2585 _errHandler.sync(this); 2586 switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) { 2587 case 1: 2588 { 2589 setState(400); 2590 htmlTag(); 2591 } 2592 break; 2593 case 2: 2594 { 2595 setState(401); 2596 singletonTag(); 2597 } 2598 break; 2599 case 3: 2600 { 2601 setState(402); 2602 paragraph(); 2603 } 2604 break; 2605 case 4: 2606 { 2607 setState(403); 2608 tr(); 2609 } 2610 break; 2611 case 5: 2612 { 2613 setState(404); 2614 td(); 2615 } 2616 break; 2617 case 6: 2618 { 2619 setState(405); 2620 th(); 2621 } 2622 break; 2623 case 7: 2624 { 2625 setState(406); 2626 body(); 2627 } 2628 break; 2629 case 8: 2630 { 2631 setState(407); 2632 colgroup(); 2633 } 2634 break; 2635 case 9: 2636 { 2637 setState(408); 2638 dd(); 2639 } 2640 break; 2641 case 10: 2642 { 2643 setState(409); 2644 dt(); 2645 } 2646 break; 2647 case 11: 2648 { 2649 setState(410); 2650 head(); 2651 } 2652 break; 2653 case 12: 2654 { 2655 setState(411); 2656 html(); 2657 } 2658 break; 2659 case 13: 2660 { 2661 setState(412); 2662 option(); 2663 } 2664 break; 2665 case 14: 2666 { 2667 setState(413); 2668 tbody(); 2669 } 2670 break; 2671 case 15: 2672 { 2673 setState(414); 2674 thead(); 2675 } 2676 break; 2677 case 16: 2678 { 2679 setState(415); 2680 tfoot(); 2681 } 2682 break; 2683 case 17: 2684 { 2685 setState(416); 2686 pTagOpen(); 2687 } 2688 break; 2689 case 18: 2690 { 2691 setState(417); 2692 trTagOpen(); 2693 } 2694 break; 2695 case 19: 2696 { 2697 setState(418); 2698 tdTagOpen(); 2699 } 2700 break; 2701 case 20: 2702 { 2703 setState(419); 2704 thTagOpen(); 2705 } 2706 break; 2707 case 21: 2708 { 2709 setState(420); 2710 bodyTagOpen(); 2711 } 2712 break; 2713 case 22: 2714 { 2715 setState(421); 2716 colgroupTagOpen(); 2717 } 2718 break; 2719 case 23: 2720 { 2721 setState(422); 2722 ddTagOpen(); 2723 } 2724 break; 2725 case 24: 2726 { 2727 setState(423); 2728 dtTagOpen(); 2729 } 2730 break; 2731 case 25: 2732 { 2733 setState(424); 2734 headTagOpen(); 2735 } 2736 break; 2737 case 26: 2738 { 2739 setState(425); 2740 htmlTagOpen(); 2741 } 2742 break; 2743 case 27: 2744 { 2745 setState(426); 2746 optionTagOpen(); 2747 } 2748 break; 2749 case 28: 2750 { 2751 setState(427); 2752 tbodyTagOpen(); 2753 } 2754 break; 2755 case 29: 2756 { 2757 setState(428); 2758 theadTagOpen(); 2759 } 2760 break; 2761 case 30: 2762 { 2763 setState(429); 2764 tfootTagOpen(); 2765 } 2766 break; 2767 case 31: 2768 { 2769 { 2770 setState(430); 2771 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2772 setState(431); 2773 match(LEADING_ASTERISK); 2774 } 2775 } 2776 break; 2777 case 32: 2778 { 2779 setState(432); 2780 htmlComment(); 2781 } 2782 break; 2783 case 33: 2784 { 2785 setState(433); 2786 match(CDATA); 2787 } 2788 break; 2789 case 34: 2790 { 2791 setState(434); 2792 match(NEWLINE); 2793 } 2794 break; 2795 case 35: 2796 { 2797 setState(435); 2798 text(); 2799 } 2800 break; 2801 case 36: 2802 { 2803 setState(436); 2804 javadocInlineTag(); 2805 } 2806 break; 2807 } 2808 } 2809 } 2810 setState(441); 2811 _errHandler.sync(this); 2812 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 2813 } 2814 setState(442); 2815 liTagClose(); 2816 } 2817 } 2818 catch (RecognitionException re) { 2819 _localctx.exception = re; 2820 _errHandler.reportError(this, re); 2821 _errHandler.recover(this, re); 2822 } 2823 finally { 2824 exitRule(); 2825 } 2826 return _localctx; 2827 } 2828 2829 public static class TrTagOpenContext extends ParserRuleContext { 2830 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2831 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2832 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2833 public List<AttributeContext> attribute() { 2834 return getRuleContexts(AttributeContext.class); 2835 } 2836 public AttributeContext attribute(int i) { 2837 return getRuleContext(AttributeContext.class,i); 2838 } 2839 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2840 public TerminalNode NEWLINE(int i) { 2841 return getToken(JavadocParser.NEWLINE, i); 2842 } 2843 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2844 public TerminalNode LEADING_ASTERISK(int i) { 2845 return getToken(JavadocParser.LEADING_ASTERISK, i); 2846 } 2847 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2848 public TerminalNode WS(int i) { 2849 return getToken(JavadocParser.WS, i); 2850 } 2851 public TrTagOpenContext(ParserRuleContext parent, int invokingState) { 2852 super(parent, invokingState); 2853 } 2854 @Override public int getRuleIndex() { return RULE_trTagOpen; } 2855 @Override 2856 public void enterRule(ParseTreeListener listener) { 2857 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagOpen(this); 2858 } 2859 @Override 2860 public void exitRule(ParseTreeListener listener) { 2861 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagOpen(this); 2862 } 2863 @Override 2864 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2865 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagOpen(this); 2866 else return visitor.visitChildren(this); 2867 } 2868 } 2869 2870 public final TrTagOpenContext trTagOpen() throws RecognitionException { 2871 TrTagOpenContext _localctx = new TrTagOpenContext(_ctx, getState()); 2872 enterRule(_localctx, 24, RULE_trTagOpen); 2873 int _la; 2874 try { 2875 enterOuterAlt(_localctx, 1); 2876 { 2877 setState(444); 2878 match(OPEN); 2879 setState(445); 2880 match(TR_HTML_TAG_NAME); 2881 setState(452); 2882 _errHandler.sync(this); 2883 _la = _input.LA(1); 2884 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2885 { 2886 setState(450); 2887 _errHandler.sync(this); 2888 switch (_input.LA(1)) { 2889 case HTML_TAG_NAME: 2890 { 2891 setState(446); 2892 attribute(); 2893 } 2894 break; 2895 case NEWLINE: 2896 { 2897 setState(447); 2898 match(NEWLINE); 2899 } 2900 break; 2901 case LEADING_ASTERISK: 2902 { 2903 setState(448); 2904 match(LEADING_ASTERISK); 2905 } 2906 break; 2907 case WS: 2908 { 2909 setState(449); 2910 match(WS); 2911 } 2912 break; 2913 default: 2914 throw new NoViableAltException(this); 2915 } 2916 } 2917 setState(454); 2918 _errHandler.sync(this); 2919 _la = _input.LA(1); 2920 } 2921 setState(455); 2922 match(CLOSE); 2923 } 2924 } 2925 catch (RecognitionException re) { 2926 _localctx.exception = re; 2927 _errHandler.reportError(this, re); 2928 _errHandler.recover(this, re); 2929 } 2930 finally { 2931 exitRule(); 2932 } 2933 return _localctx; 2934 } 2935 2936 public static class TrTagCloseContext extends ParserRuleContext { 2937 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2938 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2939 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2940 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2941 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2942 public TerminalNode NEWLINE(int i) { 2943 return getToken(JavadocParser.NEWLINE, i); 2944 } 2945 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2946 public TerminalNode LEADING_ASTERISK(int i) { 2947 return getToken(JavadocParser.LEADING_ASTERISK, i); 2948 } 2949 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2950 public TerminalNode WS(int i) { 2951 return getToken(JavadocParser.WS, i); 2952 } 2953 public TrTagCloseContext(ParserRuleContext parent, int invokingState) { 2954 super(parent, invokingState); 2955 } 2956 @Override public int getRuleIndex() { return RULE_trTagClose; } 2957 @Override 2958 public void enterRule(ParseTreeListener listener) { 2959 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagClose(this); 2960 } 2961 @Override 2962 public void exitRule(ParseTreeListener listener) { 2963 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagClose(this); 2964 } 2965 @Override 2966 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2967 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagClose(this); 2968 else return visitor.visitChildren(this); 2969 } 2970 } 2971 2972 public final TrTagCloseContext trTagClose() throws RecognitionException { 2973 TrTagCloseContext _localctx = new TrTagCloseContext(_ctx, getState()); 2974 enterRule(_localctx, 26, RULE_trTagClose); 2975 int _la; 2976 try { 2977 enterOuterAlt(_localctx, 1); 2978 { 2979 setState(457); 2980 match(OPEN); 2981 setState(458); 2982 match(SLASH); 2983 setState(459); 2984 match(TR_HTML_TAG_NAME); 2985 setState(463); 2986 _errHandler.sync(this); 2987 _la = _input.LA(1); 2988 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2989 { 2990 { 2991 setState(460); 2992 _la = _input.LA(1); 2993 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2994 _errHandler.recoverInline(this); 2995 } 2996 else { 2997 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 2998 _errHandler.reportMatch(this); 2999 consume(); 3000 } 3001 } 3002 } 3003 setState(465); 3004 _errHandler.sync(this); 3005 _la = _input.LA(1); 3006 } 3007 setState(466); 3008 match(CLOSE); 3009 } 3010 } 3011 catch (RecognitionException re) { 3012 _localctx.exception = re; 3013 _errHandler.reportError(this, re); 3014 _errHandler.recover(this, re); 3015 } 3016 finally { 3017 exitRule(); 3018 } 3019 return _localctx; 3020 } 3021 3022 public static class TrContext extends ParserRuleContext { 3023 public TrTagOpenContext trTagOpen() { 3024 return getRuleContext(TrTagOpenContext.class,0); 3025 } 3026 public TrTagCloseContext trTagClose() { 3027 return getRuleContext(TrTagCloseContext.class,0); 3028 } 3029 public List<HtmlTagContext> htmlTag() { 3030 return getRuleContexts(HtmlTagContext.class); 3031 } 3032 public HtmlTagContext htmlTag(int i) { 3033 return getRuleContext(HtmlTagContext.class,i); 3034 } 3035 public List<SingletonTagContext> singletonTag() { 3036 return getRuleContexts(SingletonTagContext.class); 3037 } 3038 public SingletonTagContext singletonTag(int i) { 3039 return getRuleContext(SingletonTagContext.class,i); 3040 } 3041 public List<ParagraphContext> paragraph() { 3042 return getRuleContexts(ParagraphContext.class); 3043 } 3044 public ParagraphContext paragraph(int i) { 3045 return getRuleContext(ParagraphContext.class,i); 3046 } 3047 public List<LiContext> li() { 3048 return getRuleContexts(LiContext.class); 3049 } 3050 public LiContext li(int i) { 3051 return getRuleContext(LiContext.class,i); 3052 } 3053 public List<TdContext> td() { 3054 return getRuleContexts(TdContext.class); 3055 } 3056 public TdContext td(int i) { 3057 return getRuleContext(TdContext.class,i); 3058 } 3059 public List<ThContext> th() { 3060 return getRuleContexts(ThContext.class); 3061 } 3062 public ThContext th(int i) { 3063 return getRuleContext(ThContext.class,i); 3064 } 3065 public List<BodyContext> body() { 3066 return getRuleContexts(BodyContext.class); 3067 } 3068 public BodyContext body(int i) { 3069 return getRuleContext(BodyContext.class,i); 3070 } 3071 public List<ColgroupContext> colgroup() { 3072 return getRuleContexts(ColgroupContext.class); 3073 } 3074 public ColgroupContext colgroup(int i) { 3075 return getRuleContext(ColgroupContext.class,i); 3076 } 3077 public List<DdContext> dd() { 3078 return getRuleContexts(DdContext.class); 3079 } 3080 public DdContext dd(int i) { 3081 return getRuleContext(DdContext.class,i); 3082 } 3083 public List<DtContext> dt() { 3084 return getRuleContexts(DtContext.class); 3085 } 3086 public DtContext dt(int i) { 3087 return getRuleContext(DtContext.class,i); 3088 } 3089 public List<HeadContext> head() { 3090 return getRuleContexts(HeadContext.class); 3091 } 3092 public HeadContext head(int i) { 3093 return getRuleContext(HeadContext.class,i); 3094 } 3095 public List<HtmlContext> html() { 3096 return getRuleContexts(HtmlContext.class); 3097 } 3098 public HtmlContext html(int i) { 3099 return getRuleContext(HtmlContext.class,i); 3100 } 3101 public List<OptionContext> option() { 3102 return getRuleContexts(OptionContext.class); 3103 } 3104 public OptionContext option(int i) { 3105 return getRuleContext(OptionContext.class,i); 3106 } 3107 public List<TbodyContext> tbody() { 3108 return getRuleContexts(TbodyContext.class); 3109 } 3110 public TbodyContext tbody(int i) { 3111 return getRuleContext(TbodyContext.class,i); 3112 } 3113 public List<TheadContext> thead() { 3114 return getRuleContexts(TheadContext.class); 3115 } 3116 public TheadContext thead(int i) { 3117 return getRuleContext(TheadContext.class,i); 3118 } 3119 public List<TfootContext> tfoot() { 3120 return getRuleContexts(TfootContext.class); 3121 } 3122 public TfootContext tfoot(int i) { 3123 return getRuleContext(TfootContext.class,i); 3124 } 3125 public List<PTagOpenContext> pTagOpen() { 3126 return getRuleContexts(PTagOpenContext.class); 3127 } 3128 public PTagOpenContext pTagOpen(int i) { 3129 return getRuleContext(PTagOpenContext.class,i); 3130 } 3131 public List<LiTagOpenContext> liTagOpen() { 3132 return getRuleContexts(LiTagOpenContext.class); 3133 } 3134 public LiTagOpenContext liTagOpen(int i) { 3135 return getRuleContext(LiTagOpenContext.class,i); 3136 } 3137 public List<TdTagOpenContext> tdTagOpen() { 3138 return getRuleContexts(TdTagOpenContext.class); 3139 } 3140 public TdTagOpenContext tdTagOpen(int i) { 3141 return getRuleContext(TdTagOpenContext.class,i); 3142 } 3143 public List<ThTagOpenContext> thTagOpen() { 3144 return getRuleContexts(ThTagOpenContext.class); 3145 } 3146 public ThTagOpenContext thTagOpen(int i) { 3147 return getRuleContext(ThTagOpenContext.class,i); 3148 } 3149 public List<BodyTagOpenContext> bodyTagOpen() { 3150 return getRuleContexts(BodyTagOpenContext.class); 3151 } 3152 public BodyTagOpenContext bodyTagOpen(int i) { 3153 return getRuleContext(BodyTagOpenContext.class,i); 3154 } 3155 public List<ColgroupTagOpenContext> colgroupTagOpen() { 3156 return getRuleContexts(ColgroupTagOpenContext.class); 3157 } 3158 public ColgroupTagOpenContext colgroupTagOpen(int i) { 3159 return getRuleContext(ColgroupTagOpenContext.class,i); 3160 } 3161 public List<DdTagOpenContext> ddTagOpen() { 3162 return getRuleContexts(DdTagOpenContext.class); 3163 } 3164 public DdTagOpenContext ddTagOpen(int i) { 3165 return getRuleContext(DdTagOpenContext.class,i); 3166 } 3167 public List<DtTagOpenContext> dtTagOpen() { 3168 return getRuleContexts(DtTagOpenContext.class); 3169 } 3170 public DtTagOpenContext dtTagOpen(int i) { 3171 return getRuleContext(DtTagOpenContext.class,i); 3172 } 3173 public List<HeadTagOpenContext> headTagOpen() { 3174 return getRuleContexts(HeadTagOpenContext.class); 3175 } 3176 public HeadTagOpenContext headTagOpen(int i) { 3177 return getRuleContext(HeadTagOpenContext.class,i); 3178 } 3179 public List<HtmlTagOpenContext> htmlTagOpen() { 3180 return getRuleContexts(HtmlTagOpenContext.class); 3181 } 3182 public HtmlTagOpenContext htmlTagOpen(int i) { 3183 return getRuleContext(HtmlTagOpenContext.class,i); 3184 } 3185 public List<OptionTagOpenContext> optionTagOpen() { 3186 return getRuleContexts(OptionTagOpenContext.class); 3187 } 3188 public OptionTagOpenContext optionTagOpen(int i) { 3189 return getRuleContext(OptionTagOpenContext.class,i); 3190 } 3191 public List<TbodyTagOpenContext> tbodyTagOpen() { 3192 return getRuleContexts(TbodyTagOpenContext.class); 3193 } 3194 public TbodyTagOpenContext tbodyTagOpen(int i) { 3195 return getRuleContext(TbodyTagOpenContext.class,i); 3196 } 3197 public List<TheadTagOpenContext> theadTagOpen() { 3198 return getRuleContexts(TheadTagOpenContext.class); 3199 } 3200 public TheadTagOpenContext theadTagOpen(int i) { 3201 return getRuleContext(TheadTagOpenContext.class,i); 3202 } 3203 public List<TfootTagOpenContext> tfootTagOpen() { 3204 return getRuleContexts(TfootTagOpenContext.class); 3205 } 3206 public TfootTagOpenContext tfootTagOpen(int i) { 3207 return getRuleContext(TfootTagOpenContext.class,i); 3208 } 3209 public List<HtmlCommentContext> htmlComment() { 3210 return getRuleContexts(HtmlCommentContext.class); 3211 } 3212 public HtmlCommentContext htmlComment(int i) { 3213 return getRuleContext(HtmlCommentContext.class,i); 3214 } 3215 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3216 public TerminalNode CDATA(int i) { 3217 return getToken(JavadocParser.CDATA, i); 3218 } 3219 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3220 public TerminalNode NEWLINE(int i) { 3221 return getToken(JavadocParser.NEWLINE, i); 3222 } 3223 public List<TextContext> text() { 3224 return getRuleContexts(TextContext.class); 3225 } 3226 public TextContext text(int i) { 3227 return getRuleContext(TextContext.class,i); 3228 } 3229 public List<JavadocInlineTagContext> javadocInlineTag() { 3230 return getRuleContexts(JavadocInlineTagContext.class); 3231 } 3232 public JavadocInlineTagContext javadocInlineTag(int i) { 3233 return getRuleContext(JavadocInlineTagContext.class,i); 3234 } 3235 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3236 public TerminalNode LEADING_ASTERISK(int i) { 3237 return getToken(JavadocParser.LEADING_ASTERISK, i); 3238 } 3239 public TrContext(ParserRuleContext parent, int invokingState) { 3240 super(parent, invokingState); 3241 } 3242 @Override public int getRuleIndex() { return RULE_tr; } 3243 @Override 3244 public void enterRule(ParseTreeListener listener) { 3245 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTr(this); 3246 } 3247 @Override 3248 public void exitRule(ParseTreeListener listener) { 3249 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTr(this); 3250 } 3251 @Override 3252 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3253 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTr(this); 3254 else return visitor.visitChildren(this); 3255 } 3256 } 3257 3258 public final TrContext tr() throws RecognitionException { 3259 TrContext _localctx = new TrContext(_ctx, getState()); 3260 enterRule(_localctx, 28, RULE_tr); 3261 try { 3262 int _alt; 3263 enterOuterAlt(_localctx, 1); 3264 { 3265 setState(468); 3266 trTagOpen(); 3267 setState(508); 3268 _errHandler.sync(this); 3269 _alt = getInterpreter().adaptivePredict(_input,31,_ctx); 3270 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3271 if ( _alt==1 ) { 3272 { 3273 setState(506); 3274 _errHandler.sync(this); 3275 switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) { 3276 case 1: 3277 { 3278 setState(469); 3279 htmlTag(); 3280 } 3281 break; 3282 case 2: 3283 { 3284 setState(470); 3285 singletonTag(); 3286 } 3287 break; 3288 case 3: 3289 { 3290 setState(471); 3291 paragraph(); 3292 } 3293 break; 3294 case 4: 3295 { 3296 setState(472); 3297 li(); 3298 } 3299 break; 3300 case 5: 3301 { 3302 setState(473); 3303 td(); 3304 } 3305 break; 3306 case 6: 3307 { 3308 setState(474); 3309 th(); 3310 } 3311 break; 3312 case 7: 3313 { 3314 setState(475); 3315 body(); 3316 } 3317 break; 3318 case 8: 3319 { 3320 setState(476); 3321 colgroup(); 3322 } 3323 break; 3324 case 9: 3325 { 3326 setState(477); 3327 dd(); 3328 } 3329 break; 3330 case 10: 3331 { 3332 setState(478); 3333 dt(); 3334 } 3335 break; 3336 case 11: 3337 { 3338 setState(479); 3339 head(); 3340 } 3341 break; 3342 case 12: 3343 { 3344 setState(480); 3345 html(); 3346 } 3347 break; 3348 case 13: 3349 { 3350 setState(481); 3351 option(); 3352 } 3353 break; 3354 case 14: 3355 { 3356 setState(482); 3357 tbody(); 3358 } 3359 break; 3360 case 15: 3361 { 3362 setState(483); 3363 thead(); 3364 } 3365 break; 3366 case 16: 3367 { 3368 setState(484); 3369 tfoot(); 3370 } 3371 break; 3372 case 17: 3373 { 3374 setState(485); 3375 pTagOpen(); 3376 } 3377 break; 3378 case 18: 3379 { 3380 setState(486); 3381 liTagOpen(); 3382 } 3383 break; 3384 case 19: 3385 { 3386 setState(487); 3387 tdTagOpen(); 3388 } 3389 break; 3390 case 20: 3391 { 3392 setState(488); 3393 thTagOpen(); 3394 } 3395 break; 3396 case 21: 3397 { 3398 setState(489); 3399 bodyTagOpen(); 3400 } 3401 break; 3402 case 22: 3403 { 3404 setState(490); 3405 colgroupTagOpen(); 3406 } 3407 break; 3408 case 23: 3409 { 3410 setState(491); 3411 ddTagOpen(); 3412 } 3413 break; 3414 case 24: 3415 { 3416 setState(492); 3417 dtTagOpen(); 3418 } 3419 break; 3420 case 25: 3421 { 3422 setState(493); 3423 headTagOpen(); 3424 } 3425 break; 3426 case 26: 3427 { 3428 setState(494); 3429 htmlTagOpen(); 3430 } 3431 break; 3432 case 27: 3433 { 3434 setState(495); 3435 optionTagOpen(); 3436 } 3437 break; 3438 case 28: 3439 { 3440 setState(496); 3441 tbodyTagOpen(); 3442 } 3443 break; 3444 case 29: 3445 { 3446 setState(497); 3447 theadTagOpen(); 3448 } 3449 break; 3450 case 30: 3451 { 3452 setState(498); 3453 tfootTagOpen(); 3454 } 3455 break; 3456 case 31: 3457 { 3458 { 3459 setState(499); 3460 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 3461 setState(500); 3462 match(LEADING_ASTERISK); 3463 } 3464 } 3465 break; 3466 case 32: 3467 { 3468 setState(501); 3469 htmlComment(); 3470 } 3471 break; 3472 case 33: 3473 { 3474 setState(502); 3475 match(CDATA); 3476 } 3477 break; 3478 case 34: 3479 { 3480 setState(503); 3481 match(NEWLINE); 3482 } 3483 break; 3484 case 35: 3485 { 3486 setState(504); 3487 text(); 3488 } 3489 break; 3490 case 36: 3491 { 3492 setState(505); 3493 javadocInlineTag(); 3494 } 3495 break; 3496 } 3497 } 3498 } 3499 setState(510); 3500 _errHandler.sync(this); 3501 _alt = getInterpreter().adaptivePredict(_input,31,_ctx); 3502 } 3503 setState(511); 3504 trTagClose(); 3505 } 3506 } 3507 catch (RecognitionException re) { 3508 _localctx.exception = re; 3509 _errHandler.reportError(this, re); 3510 _errHandler.recover(this, re); 3511 } 3512 finally { 3513 exitRule(); 3514 } 3515 return _localctx; 3516 } 3517 3518 public static class TdTagOpenContext extends ParserRuleContext { 3519 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 3520 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3521 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 3522 public List<AttributeContext> attribute() { 3523 return getRuleContexts(AttributeContext.class); 3524 } 3525 public AttributeContext attribute(int i) { 3526 return getRuleContext(AttributeContext.class,i); 3527 } 3528 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3529 public TerminalNode NEWLINE(int i) { 3530 return getToken(JavadocParser.NEWLINE, i); 3531 } 3532 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3533 public TerminalNode LEADING_ASTERISK(int i) { 3534 return getToken(JavadocParser.LEADING_ASTERISK, i); 3535 } 3536 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3537 public TerminalNode WS(int i) { 3538 return getToken(JavadocParser.WS, i); 3539 } 3540 public TdTagOpenContext(ParserRuleContext parent, int invokingState) { 3541 super(parent, invokingState); 3542 } 3543 @Override public int getRuleIndex() { return RULE_tdTagOpen; } 3544 @Override 3545 public void enterRule(ParseTreeListener listener) { 3546 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagOpen(this); 3547 } 3548 @Override 3549 public void exitRule(ParseTreeListener listener) { 3550 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagOpen(this); 3551 } 3552 @Override 3553 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3554 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagOpen(this); 3555 else return visitor.visitChildren(this); 3556 } 3557 } 3558 3559 public final TdTagOpenContext tdTagOpen() throws RecognitionException { 3560 TdTagOpenContext _localctx = new TdTagOpenContext(_ctx, getState()); 3561 enterRule(_localctx, 30, RULE_tdTagOpen); 3562 int _la; 3563 try { 3564 enterOuterAlt(_localctx, 1); 3565 { 3566 setState(513); 3567 match(OPEN); 3568 setState(514); 3569 match(TD_HTML_TAG_NAME); 3570 setState(521); 3571 _errHandler.sync(this); 3572 _la = _input.LA(1); 3573 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 3574 { 3575 setState(519); 3576 _errHandler.sync(this); 3577 switch (_input.LA(1)) { 3578 case HTML_TAG_NAME: 3579 { 3580 setState(515); 3581 attribute(); 3582 } 3583 break; 3584 case NEWLINE: 3585 { 3586 setState(516); 3587 match(NEWLINE); 3588 } 3589 break; 3590 case LEADING_ASTERISK: 3591 { 3592 setState(517); 3593 match(LEADING_ASTERISK); 3594 } 3595 break; 3596 case WS: 3597 { 3598 setState(518); 3599 match(WS); 3600 } 3601 break; 3602 default: 3603 throw new NoViableAltException(this); 3604 } 3605 } 3606 setState(523); 3607 _errHandler.sync(this); 3608 _la = _input.LA(1); 3609 } 3610 setState(524); 3611 match(CLOSE); 3612 } 3613 } 3614 catch (RecognitionException re) { 3615 _localctx.exception = re; 3616 _errHandler.reportError(this, re); 3617 _errHandler.recover(this, re); 3618 } 3619 finally { 3620 exitRule(); 3621 } 3622 return _localctx; 3623 } 3624 3625 public static class TdTagCloseContext extends ParserRuleContext { 3626 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 3627 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 3628 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3629 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 3630 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3631 public TerminalNode NEWLINE(int i) { 3632 return getToken(JavadocParser.NEWLINE, i); 3633 } 3634 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3635 public TerminalNode LEADING_ASTERISK(int i) { 3636 return getToken(JavadocParser.LEADING_ASTERISK, i); 3637 } 3638 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3639 public TerminalNode WS(int i) { 3640 return getToken(JavadocParser.WS, i); 3641 } 3642 public TdTagCloseContext(ParserRuleContext parent, int invokingState) { 3643 super(parent, invokingState); 3644 } 3645 @Override public int getRuleIndex() { return RULE_tdTagClose; } 3646 @Override 3647 public void enterRule(ParseTreeListener listener) { 3648 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagClose(this); 3649 } 3650 @Override 3651 public void exitRule(ParseTreeListener listener) { 3652 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagClose(this); 3653 } 3654 @Override 3655 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3656 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagClose(this); 3657 else return visitor.visitChildren(this); 3658 } 3659 } 3660 3661 public final TdTagCloseContext tdTagClose() throws RecognitionException { 3662 TdTagCloseContext _localctx = new TdTagCloseContext(_ctx, getState()); 3663 enterRule(_localctx, 32, RULE_tdTagClose); 3664 int _la; 3665 try { 3666 enterOuterAlt(_localctx, 1); 3667 { 3668 setState(526); 3669 match(OPEN); 3670 setState(527); 3671 match(SLASH); 3672 setState(528); 3673 match(TD_HTML_TAG_NAME); 3674 setState(532); 3675 _errHandler.sync(this); 3676 _la = _input.LA(1); 3677 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3678 { 3679 { 3680 setState(529); 3681 _la = _input.LA(1); 3682 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3683 _errHandler.recoverInline(this); 3684 } 3685 else { 3686 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 3687 _errHandler.reportMatch(this); 3688 consume(); 3689 } 3690 } 3691 } 3692 setState(534); 3693 _errHandler.sync(this); 3694 _la = _input.LA(1); 3695 } 3696 setState(535); 3697 match(CLOSE); 3698 } 3699 } 3700 catch (RecognitionException re) { 3701 _localctx.exception = re; 3702 _errHandler.reportError(this, re); 3703 _errHandler.recover(this, re); 3704 } 3705 finally { 3706 exitRule(); 3707 } 3708 return _localctx; 3709 } 3710 3711 public static class TdContext extends ParserRuleContext { 3712 public List<TdTagOpenContext> tdTagOpen() { 3713 return getRuleContexts(TdTagOpenContext.class); 3714 } 3715 public TdTagOpenContext tdTagOpen(int i) { 3716 return getRuleContext(TdTagOpenContext.class,i); 3717 } 3718 public TdTagCloseContext tdTagClose() { 3719 return getRuleContext(TdTagCloseContext.class,0); 3720 } 3721 public List<HtmlTagContext> htmlTag() { 3722 return getRuleContexts(HtmlTagContext.class); 3723 } 3724 public HtmlTagContext htmlTag(int i) { 3725 return getRuleContext(HtmlTagContext.class,i); 3726 } 3727 public List<SingletonTagContext> singletonTag() { 3728 return getRuleContexts(SingletonTagContext.class); 3729 } 3730 public SingletonTagContext singletonTag(int i) { 3731 return getRuleContext(SingletonTagContext.class,i); 3732 } 3733 public List<ParagraphContext> paragraph() { 3734 return getRuleContexts(ParagraphContext.class); 3735 } 3736 public ParagraphContext paragraph(int i) { 3737 return getRuleContext(ParagraphContext.class,i); 3738 } 3739 public List<LiContext> li() { 3740 return getRuleContexts(LiContext.class); 3741 } 3742 public LiContext li(int i) { 3743 return getRuleContext(LiContext.class,i); 3744 } 3745 public List<TrContext> tr() { 3746 return getRuleContexts(TrContext.class); 3747 } 3748 public TrContext tr(int i) { 3749 return getRuleContext(TrContext.class,i); 3750 } 3751 public List<ThContext> th() { 3752 return getRuleContexts(ThContext.class); 3753 } 3754 public ThContext th(int i) { 3755 return getRuleContext(ThContext.class,i); 3756 } 3757 public List<BodyContext> body() { 3758 return getRuleContexts(BodyContext.class); 3759 } 3760 public BodyContext body(int i) { 3761 return getRuleContext(BodyContext.class,i); 3762 } 3763 public List<ColgroupContext> colgroup() { 3764 return getRuleContexts(ColgroupContext.class); 3765 } 3766 public ColgroupContext colgroup(int i) { 3767 return getRuleContext(ColgroupContext.class,i); 3768 } 3769 public List<DdContext> dd() { 3770 return getRuleContexts(DdContext.class); 3771 } 3772 public DdContext dd(int i) { 3773 return getRuleContext(DdContext.class,i); 3774 } 3775 public List<DtContext> dt() { 3776 return getRuleContexts(DtContext.class); 3777 } 3778 public DtContext dt(int i) { 3779 return getRuleContext(DtContext.class,i); 3780 } 3781 public List<HeadContext> head() { 3782 return getRuleContexts(HeadContext.class); 3783 } 3784 public HeadContext head(int i) { 3785 return getRuleContext(HeadContext.class,i); 3786 } 3787 public List<HtmlContext> html() { 3788 return getRuleContexts(HtmlContext.class); 3789 } 3790 public HtmlContext html(int i) { 3791 return getRuleContext(HtmlContext.class,i); 3792 } 3793 public List<OptionContext> option() { 3794 return getRuleContexts(OptionContext.class); 3795 } 3796 public OptionContext option(int i) { 3797 return getRuleContext(OptionContext.class,i); 3798 } 3799 public List<TbodyContext> tbody() { 3800 return getRuleContexts(TbodyContext.class); 3801 } 3802 public TbodyContext tbody(int i) { 3803 return getRuleContext(TbodyContext.class,i); 3804 } 3805 public List<TheadContext> thead() { 3806 return getRuleContexts(TheadContext.class); 3807 } 3808 public TheadContext thead(int i) { 3809 return getRuleContext(TheadContext.class,i); 3810 } 3811 public List<TfootContext> tfoot() { 3812 return getRuleContexts(TfootContext.class); 3813 } 3814 public TfootContext tfoot(int i) { 3815 return getRuleContext(TfootContext.class,i); 3816 } 3817 public List<PTagOpenContext> pTagOpen() { 3818 return getRuleContexts(PTagOpenContext.class); 3819 } 3820 public PTagOpenContext pTagOpen(int i) { 3821 return getRuleContext(PTagOpenContext.class,i); 3822 } 3823 public List<LiTagOpenContext> liTagOpen() { 3824 return getRuleContexts(LiTagOpenContext.class); 3825 } 3826 public LiTagOpenContext liTagOpen(int i) { 3827 return getRuleContext(LiTagOpenContext.class,i); 3828 } 3829 public List<ThTagOpenContext> thTagOpen() { 3830 return getRuleContexts(ThTagOpenContext.class); 3831 } 3832 public ThTagOpenContext thTagOpen(int i) { 3833 return getRuleContext(ThTagOpenContext.class,i); 3834 } 3835 public List<BodyTagOpenContext> bodyTagOpen() { 3836 return getRuleContexts(BodyTagOpenContext.class); 3837 } 3838 public BodyTagOpenContext bodyTagOpen(int i) { 3839 return getRuleContext(BodyTagOpenContext.class,i); 3840 } 3841 public List<ColgroupTagOpenContext> colgroupTagOpen() { 3842 return getRuleContexts(ColgroupTagOpenContext.class); 3843 } 3844 public ColgroupTagOpenContext colgroupTagOpen(int i) { 3845 return getRuleContext(ColgroupTagOpenContext.class,i); 3846 } 3847 public List<DdTagOpenContext> ddTagOpen() { 3848 return getRuleContexts(DdTagOpenContext.class); 3849 } 3850 public DdTagOpenContext ddTagOpen(int i) { 3851 return getRuleContext(DdTagOpenContext.class,i); 3852 } 3853 public List<DtTagOpenContext> dtTagOpen() { 3854 return getRuleContexts(DtTagOpenContext.class); 3855 } 3856 public DtTagOpenContext dtTagOpen(int i) { 3857 return getRuleContext(DtTagOpenContext.class,i); 3858 } 3859 public List<HeadTagOpenContext> headTagOpen() { 3860 return getRuleContexts(HeadTagOpenContext.class); 3861 } 3862 public HeadTagOpenContext headTagOpen(int i) { 3863 return getRuleContext(HeadTagOpenContext.class,i); 3864 } 3865 public List<HtmlTagOpenContext> htmlTagOpen() { 3866 return getRuleContexts(HtmlTagOpenContext.class); 3867 } 3868 public HtmlTagOpenContext htmlTagOpen(int i) { 3869 return getRuleContext(HtmlTagOpenContext.class,i); 3870 } 3871 public List<OptionTagOpenContext> optionTagOpen() { 3872 return getRuleContexts(OptionTagOpenContext.class); 3873 } 3874 public OptionTagOpenContext optionTagOpen(int i) { 3875 return getRuleContext(OptionTagOpenContext.class,i); 3876 } 3877 public List<TbodyTagOpenContext> tbodyTagOpen() { 3878 return getRuleContexts(TbodyTagOpenContext.class); 3879 } 3880 public TbodyTagOpenContext tbodyTagOpen(int i) { 3881 return getRuleContext(TbodyTagOpenContext.class,i); 3882 } 3883 public List<TheadTagOpenContext> theadTagOpen() { 3884 return getRuleContexts(TheadTagOpenContext.class); 3885 } 3886 public TheadTagOpenContext theadTagOpen(int i) { 3887 return getRuleContext(TheadTagOpenContext.class,i); 3888 } 3889 public List<TfootTagOpenContext> tfootTagOpen() { 3890 return getRuleContexts(TfootTagOpenContext.class); 3891 } 3892 public TfootTagOpenContext tfootTagOpen(int i) { 3893 return getRuleContext(TfootTagOpenContext.class,i); 3894 } 3895 public List<HtmlCommentContext> htmlComment() { 3896 return getRuleContexts(HtmlCommentContext.class); 3897 } 3898 public HtmlCommentContext htmlComment(int i) { 3899 return getRuleContext(HtmlCommentContext.class,i); 3900 } 3901 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3902 public TerminalNode CDATA(int i) { 3903 return getToken(JavadocParser.CDATA, i); 3904 } 3905 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3906 public TerminalNode NEWLINE(int i) { 3907 return getToken(JavadocParser.NEWLINE, i); 3908 } 3909 public List<TextContext> text() { 3910 return getRuleContexts(TextContext.class); 3911 } 3912 public TextContext text(int i) { 3913 return getRuleContext(TextContext.class,i); 3914 } 3915 public List<JavadocInlineTagContext> javadocInlineTag() { 3916 return getRuleContexts(JavadocInlineTagContext.class); 3917 } 3918 public JavadocInlineTagContext javadocInlineTag(int i) { 3919 return getRuleContext(JavadocInlineTagContext.class,i); 3920 } 3921 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3922 public TerminalNode LEADING_ASTERISK(int i) { 3923 return getToken(JavadocParser.LEADING_ASTERISK, i); 3924 } 3925 public TdContext(ParserRuleContext parent, int invokingState) { 3926 super(parent, invokingState); 3927 } 3928 @Override public int getRuleIndex() { return RULE_td; } 3929 @Override 3930 public void enterRule(ParseTreeListener listener) { 3931 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTd(this); 3932 } 3933 @Override 3934 public void exitRule(ParseTreeListener listener) { 3935 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTd(this); 3936 } 3937 @Override 3938 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3939 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTd(this); 3940 else return visitor.visitChildren(this); 3941 } 3942 } 3943 3944 public final TdContext td() throws RecognitionException { 3945 TdContext _localctx = new TdContext(_ctx, getState()); 3946 enterRule(_localctx, 34, RULE_td); 3947 try { 3948 int _alt; 3949 enterOuterAlt(_localctx, 1); 3950 { 3951 setState(537); 3952 tdTagOpen(); 3953 setState(577); 3954 _errHandler.sync(this); 3955 _alt = getInterpreter().adaptivePredict(_input,36,_ctx); 3956 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3957 if ( _alt==1 ) { 3958 { 3959 setState(575); 3960 _errHandler.sync(this); 3961 switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { 3962 case 1: 3963 { 3964 setState(538); 3965 htmlTag(); 3966 } 3967 break; 3968 case 2: 3969 { 3970 setState(539); 3971 singletonTag(); 3972 } 3973 break; 3974 case 3: 3975 { 3976 setState(540); 3977 paragraph(); 3978 } 3979 break; 3980 case 4: 3981 { 3982 setState(541); 3983 li(); 3984 } 3985 break; 3986 case 5: 3987 { 3988 setState(542); 3989 tr(); 3990 } 3991 break; 3992 case 6: 3993 { 3994 setState(543); 3995 th(); 3996 } 3997 break; 3998 case 7: 3999 { 4000 setState(544); 4001 body(); 4002 } 4003 break; 4004 case 8: 4005 { 4006 setState(545); 4007 colgroup(); 4008 } 4009 break; 4010 case 9: 4011 { 4012 setState(546); 4013 dd(); 4014 } 4015 break; 4016 case 10: 4017 { 4018 setState(547); 4019 dt(); 4020 } 4021 break; 4022 case 11: 4023 { 4024 setState(548); 4025 head(); 4026 } 4027 break; 4028 case 12: 4029 { 4030 setState(549); 4031 html(); 4032 } 4033 break; 4034 case 13: 4035 { 4036 setState(550); 4037 option(); 4038 } 4039 break; 4040 case 14: 4041 { 4042 setState(551); 4043 tbody(); 4044 } 4045 break; 4046 case 15: 4047 { 4048 setState(552); 4049 thead(); 4050 } 4051 break; 4052 case 16: 4053 { 4054 setState(553); 4055 tfoot(); 4056 } 4057 break; 4058 case 17: 4059 { 4060 setState(554); 4061 pTagOpen(); 4062 } 4063 break; 4064 case 18: 4065 { 4066 setState(555); 4067 liTagOpen(); 4068 } 4069 break; 4070 case 19: 4071 { 4072 setState(556); 4073 tdTagOpen(); 4074 } 4075 break; 4076 case 20: 4077 { 4078 setState(557); 4079 thTagOpen(); 4080 } 4081 break; 4082 case 21: 4083 { 4084 setState(558); 4085 bodyTagOpen(); 4086 } 4087 break; 4088 case 22: 4089 { 4090 setState(559); 4091 colgroupTagOpen(); 4092 } 4093 break; 4094 case 23: 4095 { 4096 setState(560); 4097 ddTagOpen(); 4098 } 4099 break; 4100 case 24: 4101 { 4102 setState(561); 4103 dtTagOpen(); 4104 } 4105 break; 4106 case 25: 4107 { 4108 setState(562); 4109 headTagOpen(); 4110 } 4111 break; 4112 case 26: 4113 { 4114 setState(563); 4115 htmlTagOpen(); 4116 } 4117 break; 4118 case 27: 4119 { 4120 setState(564); 4121 optionTagOpen(); 4122 } 4123 break; 4124 case 28: 4125 { 4126 setState(565); 4127 tbodyTagOpen(); 4128 } 4129 break; 4130 case 29: 4131 { 4132 setState(566); 4133 theadTagOpen(); 4134 } 4135 break; 4136 case 30: 4137 { 4138 setState(567); 4139 tfootTagOpen(); 4140 } 4141 break; 4142 case 31: 4143 { 4144 { 4145 setState(568); 4146 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4147 setState(569); 4148 match(LEADING_ASTERISK); 4149 } 4150 } 4151 break; 4152 case 32: 4153 { 4154 setState(570); 4155 htmlComment(); 4156 } 4157 break; 4158 case 33: 4159 { 4160 setState(571); 4161 match(CDATA); 4162 } 4163 break; 4164 case 34: 4165 { 4166 setState(572); 4167 match(NEWLINE); 4168 } 4169 break; 4170 case 35: 4171 { 4172 setState(573); 4173 text(); 4174 } 4175 break; 4176 case 36: 4177 { 4178 setState(574); 4179 javadocInlineTag(); 4180 } 4181 break; 4182 } 4183 } 4184 } 4185 setState(579); 4186 _errHandler.sync(this); 4187 _alt = getInterpreter().adaptivePredict(_input,36,_ctx); 4188 } 4189 setState(580); 4190 tdTagClose(); 4191 } 4192 } 4193 catch (RecognitionException re) { 4194 _localctx.exception = re; 4195 _errHandler.reportError(this, re); 4196 _errHandler.recover(this, re); 4197 } 4198 finally { 4199 exitRule(); 4200 } 4201 return _localctx; 4202 } 4203 4204 public static class ThTagOpenContext extends ParserRuleContext { 4205 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4206 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4207 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4208 public List<AttributeContext> attribute() { 4209 return getRuleContexts(AttributeContext.class); 4210 } 4211 public AttributeContext attribute(int i) { 4212 return getRuleContext(AttributeContext.class,i); 4213 } 4214 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4215 public TerminalNode NEWLINE(int i) { 4216 return getToken(JavadocParser.NEWLINE, i); 4217 } 4218 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4219 public TerminalNode LEADING_ASTERISK(int i) { 4220 return getToken(JavadocParser.LEADING_ASTERISK, i); 4221 } 4222 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4223 public TerminalNode WS(int i) { 4224 return getToken(JavadocParser.WS, i); 4225 } 4226 public ThTagOpenContext(ParserRuleContext parent, int invokingState) { 4227 super(parent, invokingState); 4228 } 4229 @Override public int getRuleIndex() { return RULE_thTagOpen; } 4230 @Override 4231 public void enterRule(ParseTreeListener listener) { 4232 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagOpen(this); 4233 } 4234 @Override 4235 public void exitRule(ParseTreeListener listener) { 4236 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagOpen(this); 4237 } 4238 @Override 4239 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4240 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagOpen(this); 4241 else return visitor.visitChildren(this); 4242 } 4243 } 4244 4245 public final ThTagOpenContext thTagOpen() throws RecognitionException { 4246 ThTagOpenContext _localctx = new ThTagOpenContext(_ctx, getState()); 4247 enterRule(_localctx, 36, RULE_thTagOpen); 4248 int _la; 4249 try { 4250 enterOuterAlt(_localctx, 1); 4251 { 4252 setState(582); 4253 match(OPEN); 4254 setState(583); 4255 match(TH_HTML_TAG_NAME); 4256 setState(590); 4257 _errHandler.sync(this); 4258 _la = _input.LA(1); 4259 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4260 { 4261 setState(588); 4262 _errHandler.sync(this); 4263 switch (_input.LA(1)) { 4264 case HTML_TAG_NAME: 4265 { 4266 setState(584); 4267 attribute(); 4268 } 4269 break; 4270 case NEWLINE: 4271 { 4272 setState(585); 4273 match(NEWLINE); 4274 } 4275 break; 4276 case LEADING_ASTERISK: 4277 { 4278 setState(586); 4279 match(LEADING_ASTERISK); 4280 } 4281 break; 4282 case WS: 4283 { 4284 setState(587); 4285 match(WS); 4286 } 4287 break; 4288 default: 4289 throw new NoViableAltException(this); 4290 } 4291 } 4292 setState(592); 4293 _errHandler.sync(this); 4294 _la = _input.LA(1); 4295 } 4296 setState(593); 4297 match(CLOSE); 4298 } 4299 } 4300 catch (RecognitionException re) { 4301 _localctx.exception = re; 4302 _errHandler.reportError(this, re); 4303 _errHandler.recover(this, re); 4304 } 4305 finally { 4306 exitRule(); 4307 } 4308 return _localctx; 4309 } 4310 4311 public static class ThTagCloseContext extends ParserRuleContext { 4312 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4313 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4314 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4315 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4316 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4317 public TerminalNode NEWLINE(int i) { 4318 return getToken(JavadocParser.NEWLINE, i); 4319 } 4320 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4321 public TerminalNode LEADING_ASTERISK(int i) { 4322 return getToken(JavadocParser.LEADING_ASTERISK, i); 4323 } 4324 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4325 public TerminalNode WS(int i) { 4326 return getToken(JavadocParser.WS, i); 4327 } 4328 public ThTagCloseContext(ParserRuleContext parent, int invokingState) { 4329 super(parent, invokingState); 4330 } 4331 @Override public int getRuleIndex() { return RULE_thTagClose; } 4332 @Override 4333 public void enterRule(ParseTreeListener listener) { 4334 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagClose(this); 4335 } 4336 @Override 4337 public void exitRule(ParseTreeListener listener) { 4338 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagClose(this); 4339 } 4340 @Override 4341 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4342 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagClose(this); 4343 else return visitor.visitChildren(this); 4344 } 4345 } 4346 4347 public final ThTagCloseContext thTagClose() throws RecognitionException { 4348 ThTagCloseContext _localctx = new ThTagCloseContext(_ctx, getState()); 4349 enterRule(_localctx, 38, RULE_thTagClose); 4350 int _la; 4351 try { 4352 enterOuterAlt(_localctx, 1); 4353 { 4354 setState(595); 4355 match(OPEN); 4356 setState(596); 4357 match(SLASH); 4358 setState(597); 4359 match(TH_HTML_TAG_NAME); 4360 setState(601); 4361 _errHandler.sync(this); 4362 _la = _input.LA(1); 4363 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 4364 { 4365 { 4366 setState(598); 4367 _la = _input.LA(1); 4368 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 4369 _errHandler.recoverInline(this); 4370 } 4371 else { 4372 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 4373 _errHandler.reportMatch(this); 4374 consume(); 4375 } 4376 } 4377 } 4378 setState(603); 4379 _errHandler.sync(this); 4380 _la = _input.LA(1); 4381 } 4382 setState(604); 4383 match(CLOSE); 4384 } 4385 } 4386 catch (RecognitionException re) { 4387 _localctx.exception = re; 4388 _errHandler.reportError(this, re); 4389 _errHandler.recover(this, re); 4390 } 4391 finally { 4392 exitRule(); 4393 } 4394 return _localctx; 4395 } 4396 4397 public static class ThContext extends ParserRuleContext { 4398 public ThTagOpenContext thTagOpen() { 4399 return getRuleContext(ThTagOpenContext.class,0); 4400 } 4401 public ThTagCloseContext thTagClose() { 4402 return getRuleContext(ThTagCloseContext.class,0); 4403 } 4404 public List<HtmlTagContext> htmlTag() { 4405 return getRuleContexts(HtmlTagContext.class); 4406 } 4407 public HtmlTagContext htmlTag(int i) { 4408 return getRuleContext(HtmlTagContext.class,i); 4409 } 4410 public List<SingletonTagContext> singletonTag() { 4411 return getRuleContexts(SingletonTagContext.class); 4412 } 4413 public SingletonTagContext singletonTag(int i) { 4414 return getRuleContext(SingletonTagContext.class,i); 4415 } 4416 public List<ParagraphContext> paragraph() { 4417 return getRuleContexts(ParagraphContext.class); 4418 } 4419 public ParagraphContext paragraph(int i) { 4420 return getRuleContext(ParagraphContext.class,i); 4421 } 4422 public List<LiContext> li() { 4423 return getRuleContexts(LiContext.class); 4424 } 4425 public LiContext li(int i) { 4426 return getRuleContext(LiContext.class,i); 4427 } 4428 public List<TrContext> tr() { 4429 return getRuleContexts(TrContext.class); 4430 } 4431 public TrContext tr(int i) { 4432 return getRuleContext(TrContext.class,i); 4433 } 4434 public List<TdContext> td() { 4435 return getRuleContexts(TdContext.class); 4436 } 4437 public TdContext td(int i) { 4438 return getRuleContext(TdContext.class,i); 4439 } 4440 public List<BodyContext> body() { 4441 return getRuleContexts(BodyContext.class); 4442 } 4443 public BodyContext body(int i) { 4444 return getRuleContext(BodyContext.class,i); 4445 } 4446 public List<ColgroupContext> colgroup() { 4447 return getRuleContexts(ColgroupContext.class); 4448 } 4449 public ColgroupContext colgroup(int i) { 4450 return getRuleContext(ColgroupContext.class,i); 4451 } 4452 public List<DdContext> dd() { 4453 return getRuleContexts(DdContext.class); 4454 } 4455 public DdContext dd(int i) { 4456 return getRuleContext(DdContext.class,i); 4457 } 4458 public List<DtContext> dt() { 4459 return getRuleContexts(DtContext.class); 4460 } 4461 public DtContext dt(int i) { 4462 return getRuleContext(DtContext.class,i); 4463 } 4464 public List<HeadContext> head() { 4465 return getRuleContexts(HeadContext.class); 4466 } 4467 public HeadContext head(int i) { 4468 return getRuleContext(HeadContext.class,i); 4469 } 4470 public List<HtmlContext> html() { 4471 return getRuleContexts(HtmlContext.class); 4472 } 4473 public HtmlContext html(int i) { 4474 return getRuleContext(HtmlContext.class,i); 4475 } 4476 public List<OptionContext> option() { 4477 return getRuleContexts(OptionContext.class); 4478 } 4479 public OptionContext option(int i) { 4480 return getRuleContext(OptionContext.class,i); 4481 } 4482 public List<TbodyContext> tbody() { 4483 return getRuleContexts(TbodyContext.class); 4484 } 4485 public TbodyContext tbody(int i) { 4486 return getRuleContext(TbodyContext.class,i); 4487 } 4488 public List<TheadContext> thead() { 4489 return getRuleContexts(TheadContext.class); 4490 } 4491 public TheadContext thead(int i) { 4492 return getRuleContext(TheadContext.class,i); 4493 } 4494 public List<TfootContext> tfoot() { 4495 return getRuleContexts(TfootContext.class); 4496 } 4497 public TfootContext tfoot(int i) { 4498 return getRuleContext(TfootContext.class,i); 4499 } 4500 public List<PTagOpenContext> pTagOpen() { 4501 return getRuleContexts(PTagOpenContext.class); 4502 } 4503 public PTagOpenContext pTagOpen(int i) { 4504 return getRuleContext(PTagOpenContext.class,i); 4505 } 4506 public List<LiTagOpenContext> liTagOpen() { 4507 return getRuleContexts(LiTagOpenContext.class); 4508 } 4509 public LiTagOpenContext liTagOpen(int i) { 4510 return getRuleContext(LiTagOpenContext.class,i); 4511 } 4512 public List<TrTagOpenContext> trTagOpen() { 4513 return getRuleContexts(TrTagOpenContext.class); 4514 } 4515 public TrTagOpenContext trTagOpen(int i) { 4516 return getRuleContext(TrTagOpenContext.class,i); 4517 } 4518 public List<TdTagOpenContext> tdTagOpen() { 4519 return getRuleContexts(TdTagOpenContext.class); 4520 } 4521 public TdTagOpenContext tdTagOpen(int i) { 4522 return getRuleContext(TdTagOpenContext.class,i); 4523 } 4524 public List<BodyTagOpenContext> bodyTagOpen() { 4525 return getRuleContexts(BodyTagOpenContext.class); 4526 } 4527 public BodyTagOpenContext bodyTagOpen(int i) { 4528 return getRuleContext(BodyTagOpenContext.class,i); 4529 } 4530 public List<ColgroupTagOpenContext> colgroupTagOpen() { 4531 return getRuleContexts(ColgroupTagOpenContext.class); 4532 } 4533 public ColgroupTagOpenContext colgroupTagOpen(int i) { 4534 return getRuleContext(ColgroupTagOpenContext.class,i); 4535 } 4536 public List<DdTagOpenContext> ddTagOpen() { 4537 return getRuleContexts(DdTagOpenContext.class); 4538 } 4539 public DdTagOpenContext ddTagOpen(int i) { 4540 return getRuleContext(DdTagOpenContext.class,i); 4541 } 4542 public List<DtTagOpenContext> dtTagOpen() { 4543 return getRuleContexts(DtTagOpenContext.class); 4544 } 4545 public DtTagOpenContext dtTagOpen(int i) { 4546 return getRuleContext(DtTagOpenContext.class,i); 4547 } 4548 public List<HeadTagOpenContext> headTagOpen() { 4549 return getRuleContexts(HeadTagOpenContext.class); 4550 } 4551 public HeadTagOpenContext headTagOpen(int i) { 4552 return getRuleContext(HeadTagOpenContext.class,i); 4553 } 4554 public List<HtmlTagOpenContext> htmlTagOpen() { 4555 return getRuleContexts(HtmlTagOpenContext.class); 4556 } 4557 public HtmlTagOpenContext htmlTagOpen(int i) { 4558 return getRuleContext(HtmlTagOpenContext.class,i); 4559 } 4560 public List<OptionTagOpenContext> optionTagOpen() { 4561 return getRuleContexts(OptionTagOpenContext.class); 4562 } 4563 public OptionTagOpenContext optionTagOpen(int i) { 4564 return getRuleContext(OptionTagOpenContext.class,i); 4565 } 4566 public List<TbodyTagOpenContext> tbodyTagOpen() { 4567 return getRuleContexts(TbodyTagOpenContext.class); 4568 } 4569 public TbodyTagOpenContext tbodyTagOpen(int i) { 4570 return getRuleContext(TbodyTagOpenContext.class,i); 4571 } 4572 public List<TheadTagOpenContext> theadTagOpen() { 4573 return getRuleContexts(TheadTagOpenContext.class); 4574 } 4575 public TheadTagOpenContext theadTagOpen(int i) { 4576 return getRuleContext(TheadTagOpenContext.class,i); 4577 } 4578 public List<TfootTagOpenContext> tfootTagOpen() { 4579 return getRuleContexts(TfootTagOpenContext.class); 4580 } 4581 public TfootTagOpenContext tfootTagOpen(int i) { 4582 return getRuleContext(TfootTagOpenContext.class,i); 4583 } 4584 public List<HtmlCommentContext> htmlComment() { 4585 return getRuleContexts(HtmlCommentContext.class); 4586 } 4587 public HtmlCommentContext htmlComment(int i) { 4588 return getRuleContext(HtmlCommentContext.class,i); 4589 } 4590 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 4591 public TerminalNode CDATA(int i) { 4592 return getToken(JavadocParser.CDATA, i); 4593 } 4594 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4595 public TerminalNode NEWLINE(int i) { 4596 return getToken(JavadocParser.NEWLINE, i); 4597 } 4598 public List<TextContext> text() { 4599 return getRuleContexts(TextContext.class); 4600 } 4601 public TextContext text(int i) { 4602 return getRuleContext(TextContext.class,i); 4603 } 4604 public List<JavadocInlineTagContext> javadocInlineTag() { 4605 return getRuleContexts(JavadocInlineTagContext.class); 4606 } 4607 public JavadocInlineTagContext javadocInlineTag(int i) { 4608 return getRuleContext(JavadocInlineTagContext.class,i); 4609 } 4610 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4611 public TerminalNode LEADING_ASTERISK(int i) { 4612 return getToken(JavadocParser.LEADING_ASTERISK, i); 4613 } 4614 public ThContext(ParserRuleContext parent, int invokingState) { 4615 super(parent, invokingState); 4616 } 4617 @Override public int getRuleIndex() { return RULE_th; } 4618 @Override 4619 public void enterRule(ParseTreeListener listener) { 4620 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTh(this); 4621 } 4622 @Override 4623 public void exitRule(ParseTreeListener listener) { 4624 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTh(this); 4625 } 4626 @Override 4627 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4628 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTh(this); 4629 else return visitor.visitChildren(this); 4630 } 4631 } 4632 4633 public final ThContext th() throws RecognitionException { 4634 ThContext _localctx = new ThContext(_ctx, getState()); 4635 enterRule(_localctx, 40, RULE_th); 4636 try { 4637 int _alt; 4638 enterOuterAlt(_localctx, 1); 4639 { 4640 setState(606); 4641 thTagOpen(); 4642 setState(646); 4643 _errHandler.sync(this); 4644 _alt = getInterpreter().adaptivePredict(_input,41,_ctx); 4645 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 4646 if ( _alt==1 ) { 4647 { 4648 setState(644); 4649 _errHandler.sync(this); 4650 switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { 4651 case 1: 4652 { 4653 setState(607); 4654 htmlTag(); 4655 } 4656 break; 4657 case 2: 4658 { 4659 setState(608); 4660 singletonTag(); 4661 } 4662 break; 4663 case 3: 4664 { 4665 setState(609); 4666 paragraph(); 4667 } 4668 break; 4669 case 4: 4670 { 4671 setState(610); 4672 li(); 4673 } 4674 break; 4675 case 5: 4676 { 4677 setState(611); 4678 tr(); 4679 } 4680 break; 4681 case 6: 4682 { 4683 setState(612); 4684 td(); 4685 } 4686 break; 4687 case 7: 4688 { 4689 setState(613); 4690 body(); 4691 } 4692 break; 4693 case 8: 4694 { 4695 setState(614); 4696 colgroup(); 4697 } 4698 break; 4699 case 9: 4700 { 4701 setState(615); 4702 dd(); 4703 } 4704 break; 4705 case 10: 4706 { 4707 setState(616); 4708 dt(); 4709 } 4710 break; 4711 case 11: 4712 { 4713 setState(617); 4714 head(); 4715 } 4716 break; 4717 case 12: 4718 { 4719 setState(618); 4720 html(); 4721 } 4722 break; 4723 case 13: 4724 { 4725 setState(619); 4726 option(); 4727 } 4728 break; 4729 case 14: 4730 { 4731 setState(620); 4732 tbody(); 4733 } 4734 break; 4735 case 15: 4736 { 4737 setState(621); 4738 thead(); 4739 } 4740 break; 4741 case 16: 4742 { 4743 setState(622); 4744 tfoot(); 4745 } 4746 break; 4747 case 17: 4748 { 4749 setState(623); 4750 pTagOpen(); 4751 } 4752 break; 4753 case 18: 4754 { 4755 setState(624); 4756 liTagOpen(); 4757 } 4758 break; 4759 case 19: 4760 { 4761 setState(625); 4762 trTagOpen(); 4763 } 4764 break; 4765 case 20: 4766 { 4767 setState(626); 4768 tdTagOpen(); 4769 } 4770 break; 4771 case 21: 4772 { 4773 setState(627); 4774 bodyTagOpen(); 4775 } 4776 break; 4777 case 22: 4778 { 4779 setState(628); 4780 colgroupTagOpen(); 4781 } 4782 break; 4783 case 23: 4784 { 4785 setState(629); 4786 ddTagOpen(); 4787 } 4788 break; 4789 case 24: 4790 { 4791 setState(630); 4792 dtTagOpen(); 4793 } 4794 break; 4795 case 25: 4796 { 4797 setState(631); 4798 headTagOpen(); 4799 } 4800 break; 4801 case 26: 4802 { 4803 setState(632); 4804 htmlTagOpen(); 4805 } 4806 break; 4807 case 27: 4808 { 4809 setState(633); 4810 optionTagOpen(); 4811 } 4812 break; 4813 case 28: 4814 { 4815 setState(634); 4816 tbodyTagOpen(); 4817 } 4818 break; 4819 case 29: 4820 { 4821 setState(635); 4822 theadTagOpen(); 4823 } 4824 break; 4825 case 30: 4826 { 4827 setState(636); 4828 tfootTagOpen(); 4829 } 4830 break; 4831 case 31: 4832 { 4833 { 4834 setState(637); 4835 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4836 setState(638); 4837 match(LEADING_ASTERISK); 4838 } 4839 } 4840 break; 4841 case 32: 4842 { 4843 setState(639); 4844 htmlComment(); 4845 } 4846 break; 4847 case 33: 4848 { 4849 setState(640); 4850 match(CDATA); 4851 } 4852 break; 4853 case 34: 4854 { 4855 setState(641); 4856 match(NEWLINE); 4857 } 4858 break; 4859 case 35: 4860 { 4861 setState(642); 4862 text(); 4863 } 4864 break; 4865 case 36: 4866 { 4867 setState(643); 4868 javadocInlineTag(); 4869 } 4870 break; 4871 } 4872 } 4873 } 4874 setState(648); 4875 _errHandler.sync(this); 4876 _alt = getInterpreter().adaptivePredict(_input,41,_ctx); 4877 } 4878 setState(649); 4879 thTagClose(); 4880 } 4881 } 4882 catch (RecognitionException re) { 4883 _localctx.exception = re; 4884 _errHandler.reportError(this, re); 4885 _errHandler.recover(this, re); 4886 } 4887 finally { 4888 exitRule(); 4889 } 4890 return _localctx; 4891 } 4892 4893 public static class BodyTagOpenContext extends ParserRuleContext { 4894 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4895 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 4896 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4897 public List<AttributeContext> attribute() { 4898 return getRuleContexts(AttributeContext.class); 4899 } 4900 public AttributeContext attribute(int i) { 4901 return getRuleContext(AttributeContext.class,i); 4902 } 4903 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4904 public TerminalNode NEWLINE(int i) { 4905 return getToken(JavadocParser.NEWLINE, i); 4906 } 4907 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4908 public TerminalNode LEADING_ASTERISK(int i) { 4909 return getToken(JavadocParser.LEADING_ASTERISK, i); 4910 } 4911 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4912 public TerminalNode WS(int i) { 4913 return getToken(JavadocParser.WS, i); 4914 } 4915 public BodyTagOpenContext(ParserRuleContext parent, int invokingState) { 4916 super(parent, invokingState); 4917 } 4918 @Override public int getRuleIndex() { return RULE_bodyTagOpen; } 4919 @Override 4920 public void enterRule(ParseTreeListener listener) { 4921 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagOpen(this); 4922 } 4923 @Override 4924 public void exitRule(ParseTreeListener listener) { 4925 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagOpen(this); 4926 } 4927 @Override 4928 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4929 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagOpen(this); 4930 else return visitor.visitChildren(this); 4931 } 4932 } 4933 4934 public final BodyTagOpenContext bodyTagOpen() throws RecognitionException { 4935 BodyTagOpenContext _localctx = new BodyTagOpenContext(_ctx, getState()); 4936 enterRule(_localctx, 42, RULE_bodyTagOpen); 4937 int _la; 4938 try { 4939 enterOuterAlt(_localctx, 1); 4940 { 4941 setState(651); 4942 match(OPEN); 4943 setState(652); 4944 match(BODY_HTML_TAG_NAME); 4945 setState(659); 4946 _errHandler.sync(this); 4947 _la = _input.LA(1); 4948 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4949 { 4950 setState(657); 4951 _errHandler.sync(this); 4952 switch (_input.LA(1)) { 4953 case HTML_TAG_NAME: 4954 { 4955 setState(653); 4956 attribute(); 4957 } 4958 break; 4959 case NEWLINE: 4960 { 4961 setState(654); 4962 match(NEWLINE); 4963 } 4964 break; 4965 case LEADING_ASTERISK: 4966 { 4967 setState(655); 4968 match(LEADING_ASTERISK); 4969 } 4970 break; 4971 case WS: 4972 { 4973 setState(656); 4974 match(WS); 4975 } 4976 break; 4977 default: 4978 throw new NoViableAltException(this); 4979 } 4980 } 4981 setState(661); 4982 _errHandler.sync(this); 4983 _la = _input.LA(1); 4984 } 4985 setState(662); 4986 match(CLOSE); 4987 } 4988 } 4989 catch (RecognitionException re) { 4990 _localctx.exception = re; 4991 _errHandler.reportError(this, re); 4992 _errHandler.recover(this, re); 4993 } 4994 finally { 4995 exitRule(); 4996 } 4997 return _localctx; 4998 } 4999 5000 public static class BodyTagCloseContext extends ParserRuleContext { 5001 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5002 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 5003 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 5004 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5005 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5006 public TerminalNode NEWLINE(int i) { 5007 return getToken(JavadocParser.NEWLINE, i); 5008 } 5009 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5010 public TerminalNode LEADING_ASTERISK(int i) { 5011 return getToken(JavadocParser.LEADING_ASTERISK, i); 5012 } 5013 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5014 public TerminalNode WS(int i) { 5015 return getToken(JavadocParser.WS, i); 5016 } 5017 public BodyTagCloseContext(ParserRuleContext parent, int invokingState) { 5018 super(parent, invokingState); 5019 } 5020 @Override public int getRuleIndex() { return RULE_bodyTagClose; } 5021 @Override 5022 public void enterRule(ParseTreeListener listener) { 5023 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagClose(this); 5024 } 5025 @Override 5026 public void exitRule(ParseTreeListener listener) { 5027 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagClose(this); 5028 } 5029 @Override 5030 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5031 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagClose(this); 5032 else return visitor.visitChildren(this); 5033 } 5034 } 5035 5036 public final BodyTagCloseContext bodyTagClose() throws RecognitionException { 5037 BodyTagCloseContext _localctx = new BodyTagCloseContext(_ctx, getState()); 5038 enterRule(_localctx, 44, RULE_bodyTagClose); 5039 int _la; 5040 try { 5041 enterOuterAlt(_localctx, 1); 5042 { 5043 setState(664); 5044 match(OPEN); 5045 setState(665); 5046 match(SLASH); 5047 setState(666); 5048 match(BODY_HTML_TAG_NAME); 5049 setState(670); 5050 _errHandler.sync(this); 5051 _la = _input.LA(1); 5052 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5053 { 5054 { 5055 setState(667); 5056 _la = _input.LA(1); 5057 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5058 _errHandler.recoverInline(this); 5059 } 5060 else { 5061 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 5062 _errHandler.reportMatch(this); 5063 consume(); 5064 } 5065 } 5066 } 5067 setState(672); 5068 _errHandler.sync(this); 5069 _la = _input.LA(1); 5070 } 5071 setState(673); 5072 match(CLOSE); 5073 } 5074 } 5075 catch (RecognitionException re) { 5076 _localctx.exception = re; 5077 _errHandler.reportError(this, re); 5078 _errHandler.recover(this, re); 5079 } 5080 finally { 5081 exitRule(); 5082 } 5083 return _localctx; 5084 } 5085 5086 public static class BodyContext extends ParserRuleContext { 5087 public BodyTagOpenContext bodyTagOpen() { 5088 return getRuleContext(BodyTagOpenContext.class,0); 5089 } 5090 public BodyTagCloseContext bodyTagClose() { 5091 return getRuleContext(BodyTagCloseContext.class,0); 5092 } 5093 public List<HtmlTagContext> htmlTag() { 5094 return getRuleContexts(HtmlTagContext.class); 5095 } 5096 public HtmlTagContext htmlTag(int i) { 5097 return getRuleContext(HtmlTagContext.class,i); 5098 } 5099 public List<SingletonTagContext> singletonTag() { 5100 return getRuleContexts(SingletonTagContext.class); 5101 } 5102 public SingletonTagContext singletonTag(int i) { 5103 return getRuleContext(SingletonTagContext.class,i); 5104 } 5105 public List<ParagraphContext> paragraph() { 5106 return getRuleContexts(ParagraphContext.class); 5107 } 5108 public ParagraphContext paragraph(int i) { 5109 return getRuleContext(ParagraphContext.class,i); 5110 } 5111 public List<LiContext> li() { 5112 return getRuleContexts(LiContext.class); 5113 } 5114 public LiContext li(int i) { 5115 return getRuleContext(LiContext.class,i); 5116 } 5117 public List<TrContext> tr() { 5118 return getRuleContexts(TrContext.class); 5119 } 5120 public TrContext tr(int i) { 5121 return getRuleContext(TrContext.class,i); 5122 } 5123 public List<TdContext> td() { 5124 return getRuleContexts(TdContext.class); 5125 } 5126 public TdContext td(int i) { 5127 return getRuleContext(TdContext.class,i); 5128 } 5129 public List<ThContext> th() { 5130 return getRuleContexts(ThContext.class); 5131 } 5132 public ThContext th(int i) { 5133 return getRuleContext(ThContext.class,i); 5134 } 5135 public List<ColgroupContext> colgroup() { 5136 return getRuleContexts(ColgroupContext.class); 5137 } 5138 public ColgroupContext colgroup(int i) { 5139 return getRuleContext(ColgroupContext.class,i); 5140 } 5141 public List<DdContext> dd() { 5142 return getRuleContexts(DdContext.class); 5143 } 5144 public DdContext dd(int i) { 5145 return getRuleContext(DdContext.class,i); 5146 } 5147 public List<DtContext> dt() { 5148 return getRuleContexts(DtContext.class); 5149 } 5150 public DtContext dt(int i) { 5151 return getRuleContext(DtContext.class,i); 5152 } 5153 public List<HeadContext> head() { 5154 return getRuleContexts(HeadContext.class); 5155 } 5156 public HeadContext head(int i) { 5157 return getRuleContext(HeadContext.class,i); 5158 } 5159 public List<HtmlContext> html() { 5160 return getRuleContexts(HtmlContext.class); 5161 } 5162 public HtmlContext html(int i) { 5163 return getRuleContext(HtmlContext.class,i); 5164 } 5165 public List<OptionContext> option() { 5166 return getRuleContexts(OptionContext.class); 5167 } 5168 public OptionContext option(int i) { 5169 return getRuleContext(OptionContext.class,i); 5170 } 5171 public List<TbodyContext> tbody() { 5172 return getRuleContexts(TbodyContext.class); 5173 } 5174 public TbodyContext tbody(int i) { 5175 return getRuleContext(TbodyContext.class,i); 5176 } 5177 public List<TheadContext> thead() { 5178 return getRuleContexts(TheadContext.class); 5179 } 5180 public TheadContext thead(int i) { 5181 return getRuleContext(TheadContext.class,i); 5182 } 5183 public List<TfootContext> tfoot() { 5184 return getRuleContexts(TfootContext.class); 5185 } 5186 public TfootContext tfoot(int i) { 5187 return getRuleContext(TfootContext.class,i); 5188 } 5189 public List<PTagOpenContext> pTagOpen() { 5190 return getRuleContexts(PTagOpenContext.class); 5191 } 5192 public PTagOpenContext pTagOpen(int i) { 5193 return getRuleContext(PTagOpenContext.class,i); 5194 } 5195 public List<LiTagOpenContext> liTagOpen() { 5196 return getRuleContexts(LiTagOpenContext.class); 5197 } 5198 public LiTagOpenContext liTagOpen(int i) { 5199 return getRuleContext(LiTagOpenContext.class,i); 5200 } 5201 public List<TrTagOpenContext> trTagOpen() { 5202 return getRuleContexts(TrTagOpenContext.class); 5203 } 5204 public TrTagOpenContext trTagOpen(int i) { 5205 return getRuleContext(TrTagOpenContext.class,i); 5206 } 5207 public List<TdTagOpenContext> tdTagOpen() { 5208 return getRuleContexts(TdTagOpenContext.class); 5209 } 5210 public TdTagOpenContext tdTagOpen(int i) { 5211 return getRuleContext(TdTagOpenContext.class,i); 5212 } 5213 public List<ThTagOpenContext> thTagOpen() { 5214 return getRuleContexts(ThTagOpenContext.class); 5215 } 5216 public ThTagOpenContext thTagOpen(int i) { 5217 return getRuleContext(ThTagOpenContext.class,i); 5218 } 5219 public List<ColgroupTagOpenContext> colgroupTagOpen() { 5220 return getRuleContexts(ColgroupTagOpenContext.class); 5221 } 5222 public ColgroupTagOpenContext colgroupTagOpen(int i) { 5223 return getRuleContext(ColgroupTagOpenContext.class,i); 5224 } 5225 public List<DdTagOpenContext> ddTagOpen() { 5226 return getRuleContexts(DdTagOpenContext.class); 5227 } 5228 public DdTagOpenContext ddTagOpen(int i) { 5229 return getRuleContext(DdTagOpenContext.class,i); 5230 } 5231 public List<DtTagOpenContext> dtTagOpen() { 5232 return getRuleContexts(DtTagOpenContext.class); 5233 } 5234 public DtTagOpenContext dtTagOpen(int i) { 5235 return getRuleContext(DtTagOpenContext.class,i); 5236 } 5237 public List<HeadTagOpenContext> headTagOpen() { 5238 return getRuleContexts(HeadTagOpenContext.class); 5239 } 5240 public HeadTagOpenContext headTagOpen(int i) { 5241 return getRuleContext(HeadTagOpenContext.class,i); 5242 } 5243 public List<HtmlTagOpenContext> htmlTagOpen() { 5244 return getRuleContexts(HtmlTagOpenContext.class); 5245 } 5246 public HtmlTagOpenContext htmlTagOpen(int i) { 5247 return getRuleContext(HtmlTagOpenContext.class,i); 5248 } 5249 public List<OptionTagOpenContext> optionTagOpen() { 5250 return getRuleContexts(OptionTagOpenContext.class); 5251 } 5252 public OptionTagOpenContext optionTagOpen(int i) { 5253 return getRuleContext(OptionTagOpenContext.class,i); 5254 } 5255 public List<TbodyTagOpenContext> tbodyTagOpen() { 5256 return getRuleContexts(TbodyTagOpenContext.class); 5257 } 5258 public TbodyTagOpenContext tbodyTagOpen(int i) { 5259 return getRuleContext(TbodyTagOpenContext.class,i); 5260 } 5261 public List<TheadTagOpenContext> theadTagOpen() { 5262 return getRuleContexts(TheadTagOpenContext.class); 5263 } 5264 public TheadTagOpenContext theadTagOpen(int i) { 5265 return getRuleContext(TheadTagOpenContext.class,i); 5266 } 5267 public List<TfootTagOpenContext> tfootTagOpen() { 5268 return getRuleContexts(TfootTagOpenContext.class); 5269 } 5270 public TfootTagOpenContext tfootTagOpen(int i) { 5271 return getRuleContext(TfootTagOpenContext.class,i); 5272 } 5273 public List<HtmlCommentContext> htmlComment() { 5274 return getRuleContexts(HtmlCommentContext.class); 5275 } 5276 public HtmlCommentContext htmlComment(int i) { 5277 return getRuleContext(HtmlCommentContext.class,i); 5278 } 5279 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5280 public TerminalNode CDATA(int i) { 5281 return getToken(JavadocParser.CDATA, i); 5282 } 5283 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5284 public TerminalNode NEWLINE(int i) { 5285 return getToken(JavadocParser.NEWLINE, i); 5286 } 5287 public List<TextContext> text() { 5288 return getRuleContexts(TextContext.class); 5289 } 5290 public TextContext text(int i) { 5291 return getRuleContext(TextContext.class,i); 5292 } 5293 public List<JavadocInlineTagContext> javadocInlineTag() { 5294 return getRuleContexts(JavadocInlineTagContext.class); 5295 } 5296 public JavadocInlineTagContext javadocInlineTag(int i) { 5297 return getRuleContext(JavadocInlineTagContext.class,i); 5298 } 5299 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5300 public TerminalNode LEADING_ASTERISK(int i) { 5301 return getToken(JavadocParser.LEADING_ASTERISK, i); 5302 } 5303 public BodyContext(ParserRuleContext parent, int invokingState) { 5304 super(parent, invokingState); 5305 } 5306 @Override public int getRuleIndex() { return RULE_body; } 5307 @Override 5308 public void enterRule(ParseTreeListener listener) { 5309 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBody(this); 5310 } 5311 @Override 5312 public void exitRule(ParseTreeListener listener) { 5313 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBody(this); 5314 } 5315 @Override 5316 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5317 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBody(this); 5318 else return visitor.visitChildren(this); 5319 } 5320 } 5321 5322 public final BodyContext body() throws RecognitionException { 5323 BodyContext _localctx = new BodyContext(_ctx, getState()); 5324 enterRule(_localctx, 46, RULE_body); 5325 try { 5326 int _alt; 5327 enterOuterAlt(_localctx, 1); 5328 { 5329 setState(675); 5330 bodyTagOpen(); 5331 setState(715); 5332 _errHandler.sync(this); 5333 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5334 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5335 if ( _alt==1 ) { 5336 { 5337 setState(713); 5338 _errHandler.sync(this); 5339 switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { 5340 case 1: 5341 { 5342 setState(676); 5343 htmlTag(); 5344 } 5345 break; 5346 case 2: 5347 { 5348 setState(677); 5349 singletonTag(); 5350 } 5351 break; 5352 case 3: 5353 { 5354 setState(678); 5355 paragraph(); 5356 } 5357 break; 5358 case 4: 5359 { 5360 setState(679); 5361 li(); 5362 } 5363 break; 5364 case 5: 5365 { 5366 setState(680); 5367 tr(); 5368 } 5369 break; 5370 case 6: 5371 { 5372 setState(681); 5373 td(); 5374 } 5375 break; 5376 case 7: 5377 { 5378 setState(682); 5379 th(); 5380 } 5381 break; 5382 case 8: 5383 { 5384 setState(683); 5385 colgroup(); 5386 } 5387 break; 5388 case 9: 5389 { 5390 setState(684); 5391 dd(); 5392 } 5393 break; 5394 case 10: 5395 { 5396 setState(685); 5397 dt(); 5398 } 5399 break; 5400 case 11: 5401 { 5402 setState(686); 5403 head(); 5404 } 5405 break; 5406 case 12: 5407 { 5408 setState(687); 5409 html(); 5410 } 5411 break; 5412 case 13: 5413 { 5414 setState(688); 5415 option(); 5416 } 5417 break; 5418 case 14: 5419 { 5420 setState(689); 5421 tbody(); 5422 } 5423 break; 5424 case 15: 5425 { 5426 setState(690); 5427 thead(); 5428 } 5429 break; 5430 case 16: 5431 { 5432 setState(691); 5433 tfoot(); 5434 } 5435 break; 5436 case 17: 5437 { 5438 setState(692); 5439 pTagOpen(); 5440 } 5441 break; 5442 case 18: 5443 { 5444 setState(693); 5445 liTagOpen(); 5446 } 5447 break; 5448 case 19: 5449 { 5450 setState(694); 5451 trTagOpen(); 5452 } 5453 break; 5454 case 20: 5455 { 5456 setState(695); 5457 tdTagOpen(); 5458 } 5459 break; 5460 case 21: 5461 { 5462 setState(696); 5463 thTagOpen(); 5464 } 5465 break; 5466 case 22: 5467 { 5468 setState(697); 5469 colgroupTagOpen(); 5470 } 5471 break; 5472 case 23: 5473 { 5474 setState(698); 5475 ddTagOpen(); 5476 } 5477 break; 5478 case 24: 5479 { 5480 setState(699); 5481 dtTagOpen(); 5482 } 5483 break; 5484 case 25: 5485 { 5486 setState(700); 5487 headTagOpen(); 5488 } 5489 break; 5490 case 26: 5491 { 5492 setState(701); 5493 htmlTagOpen(); 5494 } 5495 break; 5496 case 27: 5497 { 5498 setState(702); 5499 optionTagOpen(); 5500 } 5501 break; 5502 case 28: 5503 { 5504 setState(703); 5505 tbodyTagOpen(); 5506 } 5507 break; 5508 case 29: 5509 { 5510 setState(704); 5511 theadTagOpen(); 5512 } 5513 break; 5514 case 30: 5515 { 5516 setState(705); 5517 tfootTagOpen(); 5518 } 5519 break; 5520 case 31: 5521 { 5522 { 5523 setState(706); 5524 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 5525 setState(707); 5526 match(LEADING_ASTERISK); 5527 } 5528 } 5529 break; 5530 case 32: 5531 { 5532 setState(708); 5533 htmlComment(); 5534 } 5535 break; 5536 case 33: 5537 { 5538 setState(709); 5539 match(CDATA); 5540 } 5541 break; 5542 case 34: 5543 { 5544 setState(710); 5545 match(NEWLINE); 5546 } 5547 break; 5548 case 35: 5549 { 5550 setState(711); 5551 text(); 5552 } 5553 break; 5554 case 36: 5555 { 5556 setState(712); 5557 javadocInlineTag(); 5558 } 5559 break; 5560 } 5561 } 5562 } 5563 setState(717); 5564 _errHandler.sync(this); 5565 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5566 } 5567 setState(718); 5568 bodyTagClose(); 5569 } 5570 } 5571 catch (RecognitionException re) { 5572 _localctx.exception = re; 5573 _errHandler.reportError(this, re); 5574 _errHandler.recover(this, re); 5575 } 5576 finally { 5577 exitRule(); 5578 } 5579 return _localctx; 5580 } 5581 5582 public static class ColgroupTagOpenContext extends ParserRuleContext { 5583 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5584 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5585 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5586 public List<AttributeContext> attribute() { 5587 return getRuleContexts(AttributeContext.class); 5588 } 5589 public AttributeContext attribute(int i) { 5590 return getRuleContext(AttributeContext.class,i); 5591 } 5592 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5593 public TerminalNode NEWLINE(int i) { 5594 return getToken(JavadocParser.NEWLINE, i); 5595 } 5596 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5597 public TerminalNode LEADING_ASTERISK(int i) { 5598 return getToken(JavadocParser.LEADING_ASTERISK, i); 5599 } 5600 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5601 public TerminalNode WS(int i) { 5602 return getToken(JavadocParser.WS, i); 5603 } 5604 public ColgroupTagOpenContext(ParserRuleContext parent, int invokingState) { 5605 super(parent, invokingState); 5606 } 5607 @Override public int getRuleIndex() { return RULE_colgroupTagOpen; } 5608 @Override 5609 public void enterRule(ParseTreeListener listener) { 5610 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagOpen(this); 5611 } 5612 @Override 5613 public void exitRule(ParseTreeListener listener) { 5614 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagOpen(this); 5615 } 5616 @Override 5617 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5618 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagOpen(this); 5619 else return visitor.visitChildren(this); 5620 } 5621 } 5622 5623 public final ColgroupTagOpenContext colgroupTagOpen() throws RecognitionException { 5624 ColgroupTagOpenContext _localctx = new ColgroupTagOpenContext(_ctx, getState()); 5625 enterRule(_localctx, 48, RULE_colgroupTagOpen); 5626 int _la; 5627 try { 5628 enterOuterAlt(_localctx, 1); 5629 { 5630 setState(720); 5631 match(OPEN); 5632 setState(721); 5633 match(COLGROUP_HTML_TAG_NAME); 5634 setState(728); 5635 _errHandler.sync(this); 5636 _la = _input.LA(1); 5637 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 5638 { 5639 setState(726); 5640 _errHandler.sync(this); 5641 switch (_input.LA(1)) { 5642 case HTML_TAG_NAME: 5643 { 5644 setState(722); 5645 attribute(); 5646 } 5647 break; 5648 case NEWLINE: 5649 { 5650 setState(723); 5651 match(NEWLINE); 5652 } 5653 break; 5654 case LEADING_ASTERISK: 5655 { 5656 setState(724); 5657 match(LEADING_ASTERISK); 5658 } 5659 break; 5660 case WS: 5661 { 5662 setState(725); 5663 match(WS); 5664 } 5665 break; 5666 default: 5667 throw new NoViableAltException(this); 5668 } 5669 } 5670 setState(730); 5671 _errHandler.sync(this); 5672 _la = _input.LA(1); 5673 } 5674 setState(731); 5675 match(CLOSE); 5676 } 5677 } 5678 catch (RecognitionException re) { 5679 _localctx.exception = re; 5680 _errHandler.reportError(this, re); 5681 _errHandler.recover(this, re); 5682 } 5683 finally { 5684 exitRule(); 5685 } 5686 return _localctx; 5687 } 5688 5689 public static class ColgroupTagCloseContext extends ParserRuleContext { 5690 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5691 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 5692 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5693 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5694 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5695 public TerminalNode NEWLINE(int i) { 5696 return getToken(JavadocParser.NEWLINE, i); 5697 } 5698 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5699 public TerminalNode LEADING_ASTERISK(int i) { 5700 return getToken(JavadocParser.LEADING_ASTERISK, i); 5701 } 5702 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5703 public TerminalNode WS(int i) { 5704 return getToken(JavadocParser.WS, i); 5705 } 5706 public ColgroupTagCloseContext(ParserRuleContext parent, int invokingState) { 5707 super(parent, invokingState); 5708 } 5709 @Override public int getRuleIndex() { return RULE_colgroupTagClose; } 5710 @Override 5711 public void enterRule(ParseTreeListener listener) { 5712 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagClose(this); 5713 } 5714 @Override 5715 public void exitRule(ParseTreeListener listener) { 5716 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagClose(this); 5717 } 5718 @Override 5719 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5720 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagClose(this); 5721 else return visitor.visitChildren(this); 5722 } 5723 } 5724 5725 public final ColgroupTagCloseContext colgroupTagClose() throws RecognitionException { 5726 ColgroupTagCloseContext _localctx = new ColgroupTagCloseContext(_ctx, getState()); 5727 enterRule(_localctx, 50, RULE_colgroupTagClose); 5728 int _la; 5729 try { 5730 enterOuterAlt(_localctx, 1); 5731 { 5732 setState(733); 5733 match(OPEN); 5734 setState(734); 5735 match(SLASH); 5736 setState(735); 5737 match(COLGROUP_HTML_TAG_NAME); 5738 setState(739); 5739 _errHandler.sync(this); 5740 _la = _input.LA(1); 5741 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5742 { 5743 { 5744 setState(736); 5745 _la = _input.LA(1); 5746 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5747 _errHandler.recoverInline(this); 5748 } 5749 else { 5750 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 5751 _errHandler.reportMatch(this); 5752 consume(); 5753 } 5754 } 5755 } 5756 setState(741); 5757 _errHandler.sync(this); 5758 _la = _input.LA(1); 5759 } 5760 setState(742); 5761 match(CLOSE); 5762 } 5763 } 5764 catch (RecognitionException re) { 5765 _localctx.exception = re; 5766 _errHandler.reportError(this, re); 5767 _errHandler.recover(this, re); 5768 } 5769 finally { 5770 exitRule(); 5771 } 5772 return _localctx; 5773 } 5774 5775 public static class ColgroupContext extends ParserRuleContext { 5776 public ColgroupTagOpenContext colgroupTagOpen() { 5777 return getRuleContext(ColgroupTagOpenContext.class,0); 5778 } 5779 public ColgroupTagCloseContext colgroupTagClose() { 5780 return getRuleContext(ColgroupTagCloseContext.class,0); 5781 } 5782 public List<HtmlTagContext> htmlTag() { 5783 return getRuleContexts(HtmlTagContext.class); 5784 } 5785 public HtmlTagContext htmlTag(int i) { 5786 return getRuleContext(HtmlTagContext.class,i); 5787 } 5788 public List<SingletonTagContext> singletonTag() { 5789 return getRuleContexts(SingletonTagContext.class); 5790 } 5791 public SingletonTagContext singletonTag(int i) { 5792 return getRuleContext(SingletonTagContext.class,i); 5793 } 5794 public List<ParagraphContext> paragraph() { 5795 return getRuleContexts(ParagraphContext.class); 5796 } 5797 public ParagraphContext paragraph(int i) { 5798 return getRuleContext(ParagraphContext.class,i); 5799 } 5800 public List<LiContext> li() { 5801 return getRuleContexts(LiContext.class); 5802 } 5803 public LiContext li(int i) { 5804 return getRuleContext(LiContext.class,i); 5805 } 5806 public List<TrContext> tr() { 5807 return getRuleContexts(TrContext.class); 5808 } 5809 public TrContext tr(int i) { 5810 return getRuleContext(TrContext.class,i); 5811 } 5812 public List<TdContext> td() { 5813 return getRuleContexts(TdContext.class); 5814 } 5815 public TdContext td(int i) { 5816 return getRuleContext(TdContext.class,i); 5817 } 5818 public List<ThContext> th() { 5819 return getRuleContexts(ThContext.class); 5820 } 5821 public ThContext th(int i) { 5822 return getRuleContext(ThContext.class,i); 5823 } 5824 public List<BodyContext> body() { 5825 return getRuleContexts(BodyContext.class); 5826 } 5827 public BodyContext body(int i) { 5828 return getRuleContext(BodyContext.class,i); 5829 } 5830 public List<DdContext> dd() { 5831 return getRuleContexts(DdContext.class); 5832 } 5833 public DdContext dd(int i) { 5834 return getRuleContext(DdContext.class,i); 5835 } 5836 public List<DtContext> dt() { 5837 return getRuleContexts(DtContext.class); 5838 } 5839 public DtContext dt(int i) { 5840 return getRuleContext(DtContext.class,i); 5841 } 5842 public List<HeadContext> head() { 5843 return getRuleContexts(HeadContext.class); 5844 } 5845 public HeadContext head(int i) { 5846 return getRuleContext(HeadContext.class,i); 5847 } 5848 public List<HtmlContext> html() { 5849 return getRuleContexts(HtmlContext.class); 5850 } 5851 public HtmlContext html(int i) { 5852 return getRuleContext(HtmlContext.class,i); 5853 } 5854 public List<OptionContext> option() { 5855 return getRuleContexts(OptionContext.class); 5856 } 5857 public OptionContext option(int i) { 5858 return getRuleContext(OptionContext.class,i); 5859 } 5860 public List<TbodyContext> tbody() { 5861 return getRuleContexts(TbodyContext.class); 5862 } 5863 public TbodyContext tbody(int i) { 5864 return getRuleContext(TbodyContext.class,i); 5865 } 5866 public List<TheadContext> thead() { 5867 return getRuleContexts(TheadContext.class); 5868 } 5869 public TheadContext thead(int i) { 5870 return getRuleContext(TheadContext.class,i); 5871 } 5872 public List<TfootContext> tfoot() { 5873 return getRuleContexts(TfootContext.class); 5874 } 5875 public TfootContext tfoot(int i) { 5876 return getRuleContext(TfootContext.class,i); 5877 } 5878 public List<PTagOpenContext> pTagOpen() { 5879 return getRuleContexts(PTagOpenContext.class); 5880 } 5881 public PTagOpenContext pTagOpen(int i) { 5882 return getRuleContext(PTagOpenContext.class,i); 5883 } 5884 public List<LiTagOpenContext> liTagOpen() { 5885 return getRuleContexts(LiTagOpenContext.class); 5886 } 5887 public LiTagOpenContext liTagOpen(int i) { 5888 return getRuleContext(LiTagOpenContext.class,i); 5889 } 5890 public List<TrTagOpenContext> trTagOpen() { 5891 return getRuleContexts(TrTagOpenContext.class); 5892 } 5893 public TrTagOpenContext trTagOpen(int i) { 5894 return getRuleContext(TrTagOpenContext.class,i); 5895 } 5896 public List<TdTagOpenContext> tdTagOpen() { 5897 return getRuleContexts(TdTagOpenContext.class); 5898 } 5899 public TdTagOpenContext tdTagOpen(int i) { 5900 return getRuleContext(TdTagOpenContext.class,i); 5901 } 5902 public List<ThTagOpenContext> thTagOpen() { 5903 return getRuleContexts(ThTagOpenContext.class); 5904 } 5905 public ThTagOpenContext thTagOpen(int i) { 5906 return getRuleContext(ThTagOpenContext.class,i); 5907 } 5908 public List<BodyTagOpenContext> bodyTagOpen() { 5909 return getRuleContexts(BodyTagOpenContext.class); 5910 } 5911 public BodyTagOpenContext bodyTagOpen(int i) { 5912 return getRuleContext(BodyTagOpenContext.class,i); 5913 } 5914 public List<DdTagOpenContext> ddTagOpen() { 5915 return getRuleContexts(DdTagOpenContext.class); 5916 } 5917 public DdTagOpenContext ddTagOpen(int i) { 5918 return getRuleContext(DdTagOpenContext.class,i); 5919 } 5920 public List<DtTagOpenContext> dtTagOpen() { 5921 return getRuleContexts(DtTagOpenContext.class); 5922 } 5923 public DtTagOpenContext dtTagOpen(int i) { 5924 return getRuleContext(DtTagOpenContext.class,i); 5925 } 5926 public List<HeadTagOpenContext> headTagOpen() { 5927 return getRuleContexts(HeadTagOpenContext.class); 5928 } 5929 public HeadTagOpenContext headTagOpen(int i) { 5930 return getRuleContext(HeadTagOpenContext.class,i); 5931 } 5932 public List<HtmlTagOpenContext> htmlTagOpen() { 5933 return getRuleContexts(HtmlTagOpenContext.class); 5934 } 5935 public HtmlTagOpenContext htmlTagOpen(int i) { 5936 return getRuleContext(HtmlTagOpenContext.class,i); 5937 } 5938 public List<OptionTagOpenContext> optionTagOpen() { 5939 return getRuleContexts(OptionTagOpenContext.class); 5940 } 5941 public OptionTagOpenContext optionTagOpen(int i) { 5942 return getRuleContext(OptionTagOpenContext.class,i); 5943 } 5944 public List<TbodyTagOpenContext> tbodyTagOpen() { 5945 return getRuleContexts(TbodyTagOpenContext.class); 5946 } 5947 public TbodyTagOpenContext tbodyTagOpen(int i) { 5948 return getRuleContext(TbodyTagOpenContext.class,i); 5949 } 5950 public List<TheadTagOpenContext> theadTagOpen() { 5951 return getRuleContexts(TheadTagOpenContext.class); 5952 } 5953 public TheadTagOpenContext theadTagOpen(int i) { 5954 return getRuleContext(TheadTagOpenContext.class,i); 5955 } 5956 public List<TfootTagOpenContext> tfootTagOpen() { 5957 return getRuleContexts(TfootTagOpenContext.class); 5958 } 5959 public TfootTagOpenContext tfootTagOpen(int i) { 5960 return getRuleContext(TfootTagOpenContext.class,i); 5961 } 5962 public List<HtmlCommentContext> htmlComment() { 5963 return getRuleContexts(HtmlCommentContext.class); 5964 } 5965 public HtmlCommentContext htmlComment(int i) { 5966 return getRuleContext(HtmlCommentContext.class,i); 5967 } 5968 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5969 public TerminalNode CDATA(int i) { 5970 return getToken(JavadocParser.CDATA, i); 5971 } 5972 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5973 public TerminalNode NEWLINE(int i) { 5974 return getToken(JavadocParser.NEWLINE, i); 5975 } 5976 public List<TextContext> text() { 5977 return getRuleContexts(TextContext.class); 5978 } 5979 public TextContext text(int i) { 5980 return getRuleContext(TextContext.class,i); 5981 } 5982 public List<JavadocInlineTagContext> javadocInlineTag() { 5983 return getRuleContexts(JavadocInlineTagContext.class); 5984 } 5985 public JavadocInlineTagContext javadocInlineTag(int i) { 5986 return getRuleContext(JavadocInlineTagContext.class,i); 5987 } 5988 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5989 public TerminalNode LEADING_ASTERISK(int i) { 5990 return getToken(JavadocParser.LEADING_ASTERISK, i); 5991 } 5992 public ColgroupContext(ParserRuleContext parent, int invokingState) { 5993 super(parent, invokingState); 5994 } 5995 @Override public int getRuleIndex() { return RULE_colgroup; } 5996 @Override 5997 public void enterRule(ParseTreeListener listener) { 5998 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroup(this); 5999 } 6000 @Override 6001 public void exitRule(ParseTreeListener listener) { 6002 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroup(this); 6003 } 6004 @Override 6005 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6006 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroup(this); 6007 else return visitor.visitChildren(this); 6008 } 6009 } 6010 6011 public final ColgroupContext colgroup() throws RecognitionException { 6012 ColgroupContext _localctx = new ColgroupContext(_ctx, getState()); 6013 enterRule(_localctx, 52, RULE_colgroup); 6014 try { 6015 int _alt; 6016 enterOuterAlt(_localctx, 1); 6017 { 6018 setState(744); 6019 colgroupTagOpen(); 6020 setState(784); 6021 _errHandler.sync(this); 6022 _alt = getInterpreter().adaptivePredict(_input,51,_ctx); 6023 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6024 if ( _alt==1 ) { 6025 { 6026 setState(782); 6027 _errHandler.sync(this); 6028 switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { 6029 case 1: 6030 { 6031 setState(745); 6032 htmlTag(); 6033 } 6034 break; 6035 case 2: 6036 { 6037 setState(746); 6038 singletonTag(); 6039 } 6040 break; 6041 case 3: 6042 { 6043 setState(747); 6044 paragraph(); 6045 } 6046 break; 6047 case 4: 6048 { 6049 setState(748); 6050 li(); 6051 } 6052 break; 6053 case 5: 6054 { 6055 setState(749); 6056 tr(); 6057 } 6058 break; 6059 case 6: 6060 { 6061 setState(750); 6062 td(); 6063 } 6064 break; 6065 case 7: 6066 { 6067 setState(751); 6068 th(); 6069 } 6070 break; 6071 case 8: 6072 { 6073 setState(752); 6074 body(); 6075 } 6076 break; 6077 case 9: 6078 { 6079 setState(753); 6080 dd(); 6081 } 6082 break; 6083 case 10: 6084 { 6085 setState(754); 6086 dt(); 6087 } 6088 break; 6089 case 11: 6090 { 6091 setState(755); 6092 head(); 6093 } 6094 break; 6095 case 12: 6096 { 6097 setState(756); 6098 html(); 6099 } 6100 break; 6101 case 13: 6102 { 6103 setState(757); 6104 option(); 6105 } 6106 break; 6107 case 14: 6108 { 6109 setState(758); 6110 tbody(); 6111 } 6112 break; 6113 case 15: 6114 { 6115 setState(759); 6116 thead(); 6117 } 6118 break; 6119 case 16: 6120 { 6121 setState(760); 6122 tfoot(); 6123 } 6124 break; 6125 case 17: 6126 { 6127 setState(761); 6128 pTagOpen(); 6129 } 6130 break; 6131 case 18: 6132 { 6133 setState(762); 6134 liTagOpen(); 6135 } 6136 break; 6137 case 19: 6138 { 6139 setState(763); 6140 trTagOpen(); 6141 } 6142 break; 6143 case 20: 6144 { 6145 setState(764); 6146 tdTagOpen(); 6147 } 6148 break; 6149 case 21: 6150 { 6151 setState(765); 6152 thTagOpen(); 6153 } 6154 break; 6155 case 22: 6156 { 6157 setState(766); 6158 bodyTagOpen(); 6159 } 6160 break; 6161 case 23: 6162 { 6163 setState(767); 6164 ddTagOpen(); 6165 } 6166 break; 6167 case 24: 6168 { 6169 setState(768); 6170 dtTagOpen(); 6171 } 6172 break; 6173 case 25: 6174 { 6175 setState(769); 6176 headTagOpen(); 6177 } 6178 break; 6179 case 26: 6180 { 6181 setState(770); 6182 htmlTagOpen(); 6183 } 6184 break; 6185 case 27: 6186 { 6187 setState(771); 6188 optionTagOpen(); 6189 } 6190 break; 6191 case 28: 6192 { 6193 setState(772); 6194 tbodyTagOpen(); 6195 } 6196 break; 6197 case 29: 6198 { 6199 setState(773); 6200 theadTagOpen(); 6201 } 6202 break; 6203 case 30: 6204 { 6205 setState(774); 6206 tfootTagOpen(); 6207 } 6208 break; 6209 case 31: 6210 { 6211 { 6212 setState(775); 6213 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6214 setState(776); 6215 match(LEADING_ASTERISK); 6216 } 6217 } 6218 break; 6219 case 32: 6220 { 6221 setState(777); 6222 htmlComment(); 6223 } 6224 break; 6225 case 33: 6226 { 6227 setState(778); 6228 match(CDATA); 6229 } 6230 break; 6231 case 34: 6232 { 6233 setState(779); 6234 match(NEWLINE); 6235 } 6236 break; 6237 case 35: 6238 { 6239 setState(780); 6240 text(); 6241 } 6242 break; 6243 case 36: 6244 { 6245 setState(781); 6246 javadocInlineTag(); 6247 } 6248 break; 6249 } 6250 } 6251 } 6252 setState(786); 6253 _errHandler.sync(this); 6254 _alt = getInterpreter().adaptivePredict(_input,51,_ctx); 6255 } 6256 setState(787); 6257 colgroupTagClose(); 6258 } 6259 } 6260 catch (RecognitionException re) { 6261 _localctx.exception = re; 6262 _errHandler.reportError(this, re); 6263 _errHandler.recover(this, re); 6264 } 6265 finally { 6266 exitRule(); 6267 } 6268 return _localctx; 6269 } 6270 6271 public static class DdTagOpenContext extends ParserRuleContext { 6272 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6273 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6274 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6275 public List<AttributeContext> attribute() { 6276 return getRuleContexts(AttributeContext.class); 6277 } 6278 public AttributeContext attribute(int i) { 6279 return getRuleContext(AttributeContext.class,i); 6280 } 6281 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6282 public TerminalNode NEWLINE(int i) { 6283 return getToken(JavadocParser.NEWLINE, i); 6284 } 6285 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6286 public TerminalNode LEADING_ASTERISK(int i) { 6287 return getToken(JavadocParser.LEADING_ASTERISK, i); 6288 } 6289 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6290 public TerminalNode WS(int i) { 6291 return getToken(JavadocParser.WS, i); 6292 } 6293 public DdTagOpenContext(ParserRuleContext parent, int invokingState) { 6294 super(parent, invokingState); 6295 } 6296 @Override public int getRuleIndex() { return RULE_ddTagOpen; } 6297 @Override 6298 public void enterRule(ParseTreeListener listener) { 6299 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagOpen(this); 6300 } 6301 @Override 6302 public void exitRule(ParseTreeListener listener) { 6303 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagOpen(this); 6304 } 6305 @Override 6306 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6307 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagOpen(this); 6308 else return visitor.visitChildren(this); 6309 } 6310 } 6311 6312 public final DdTagOpenContext ddTagOpen() throws RecognitionException { 6313 DdTagOpenContext _localctx = new DdTagOpenContext(_ctx, getState()); 6314 enterRule(_localctx, 54, RULE_ddTagOpen); 6315 int _la; 6316 try { 6317 enterOuterAlt(_localctx, 1); 6318 { 6319 setState(789); 6320 match(OPEN); 6321 setState(790); 6322 match(DD_HTML_TAG_NAME); 6323 setState(797); 6324 _errHandler.sync(this); 6325 _la = _input.LA(1); 6326 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6327 { 6328 setState(795); 6329 _errHandler.sync(this); 6330 switch (_input.LA(1)) { 6331 case HTML_TAG_NAME: 6332 { 6333 setState(791); 6334 attribute(); 6335 } 6336 break; 6337 case NEWLINE: 6338 { 6339 setState(792); 6340 match(NEWLINE); 6341 } 6342 break; 6343 case LEADING_ASTERISK: 6344 { 6345 setState(793); 6346 match(LEADING_ASTERISK); 6347 } 6348 break; 6349 case WS: 6350 { 6351 setState(794); 6352 match(WS); 6353 } 6354 break; 6355 default: 6356 throw new NoViableAltException(this); 6357 } 6358 } 6359 setState(799); 6360 _errHandler.sync(this); 6361 _la = _input.LA(1); 6362 } 6363 setState(800); 6364 match(CLOSE); 6365 } 6366 } 6367 catch (RecognitionException re) { 6368 _localctx.exception = re; 6369 _errHandler.reportError(this, re); 6370 _errHandler.recover(this, re); 6371 } 6372 finally { 6373 exitRule(); 6374 } 6375 return _localctx; 6376 } 6377 6378 public static class DdTagCloseContext extends ParserRuleContext { 6379 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6380 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 6381 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6382 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6383 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6384 public TerminalNode NEWLINE(int i) { 6385 return getToken(JavadocParser.NEWLINE, i); 6386 } 6387 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6388 public TerminalNode LEADING_ASTERISK(int i) { 6389 return getToken(JavadocParser.LEADING_ASTERISK, i); 6390 } 6391 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6392 public TerminalNode WS(int i) { 6393 return getToken(JavadocParser.WS, i); 6394 } 6395 public DdTagCloseContext(ParserRuleContext parent, int invokingState) { 6396 super(parent, invokingState); 6397 } 6398 @Override public int getRuleIndex() { return RULE_ddTagClose; } 6399 @Override 6400 public void enterRule(ParseTreeListener listener) { 6401 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagClose(this); 6402 } 6403 @Override 6404 public void exitRule(ParseTreeListener listener) { 6405 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagClose(this); 6406 } 6407 @Override 6408 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6409 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagClose(this); 6410 else return visitor.visitChildren(this); 6411 } 6412 } 6413 6414 public final DdTagCloseContext ddTagClose() throws RecognitionException { 6415 DdTagCloseContext _localctx = new DdTagCloseContext(_ctx, getState()); 6416 enterRule(_localctx, 56, RULE_ddTagClose); 6417 int _la; 6418 try { 6419 enterOuterAlt(_localctx, 1); 6420 { 6421 setState(802); 6422 match(OPEN); 6423 setState(803); 6424 match(SLASH); 6425 setState(804); 6426 match(DD_HTML_TAG_NAME); 6427 setState(808); 6428 _errHandler.sync(this); 6429 _la = _input.LA(1); 6430 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 6431 { 6432 { 6433 setState(805); 6434 _la = _input.LA(1); 6435 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 6436 _errHandler.recoverInline(this); 6437 } 6438 else { 6439 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 6440 _errHandler.reportMatch(this); 6441 consume(); 6442 } 6443 } 6444 } 6445 setState(810); 6446 _errHandler.sync(this); 6447 _la = _input.LA(1); 6448 } 6449 setState(811); 6450 match(CLOSE); 6451 } 6452 } 6453 catch (RecognitionException re) { 6454 _localctx.exception = re; 6455 _errHandler.reportError(this, re); 6456 _errHandler.recover(this, re); 6457 } 6458 finally { 6459 exitRule(); 6460 } 6461 return _localctx; 6462 } 6463 6464 public static class DdContext extends ParserRuleContext { 6465 public DdTagOpenContext ddTagOpen() { 6466 return getRuleContext(DdTagOpenContext.class,0); 6467 } 6468 public DdTagCloseContext ddTagClose() { 6469 return getRuleContext(DdTagCloseContext.class,0); 6470 } 6471 public List<HtmlTagContext> htmlTag() { 6472 return getRuleContexts(HtmlTagContext.class); 6473 } 6474 public HtmlTagContext htmlTag(int i) { 6475 return getRuleContext(HtmlTagContext.class,i); 6476 } 6477 public List<SingletonTagContext> singletonTag() { 6478 return getRuleContexts(SingletonTagContext.class); 6479 } 6480 public SingletonTagContext singletonTag(int i) { 6481 return getRuleContext(SingletonTagContext.class,i); 6482 } 6483 public List<ParagraphContext> paragraph() { 6484 return getRuleContexts(ParagraphContext.class); 6485 } 6486 public ParagraphContext paragraph(int i) { 6487 return getRuleContext(ParagraphContext.class,i); 6488 } 6489 public List<LiContext> li() { 6490 return getRuleContexts(LiContext.class); 6491 } 6492 public LiContext li(int i) { 6493 return getRuleContext(LiContext.class,i); 6494 } 6495 public List<TrContext> tr() { 6496 return getRuleContexts(TrContext.class); 6497 } 6498 public TrContext tr(int i) { 6499 return getRuleContext(TrContext.class,i); 6500 } 6501 public List<TdContext> td() { 6502 return getRuleContexts(TdContext.class); 6503 } 6504 public TdContext td(int i) { 6505 return getRuleContext(TdContext.class,i); 6506 } 6507 public List<ThContext> th() { 6508 return getRuleContexts(ThContext.class); 6509 } 6510 public ThContext th(int i) { 6511 return getRuleContext(ThContext.class,i); 6512 } 6513 public List<BodyContext> body() { 6514 return getRuleContexts(BodyContext.class); 6515 } 6516 public BodyContext body(int i) { 6517 return getRuleContext(BodyContext.class,i); 6518 } 6519 public List<ColgroupContext> colgroup() { 6520 return getRuleContexts(ColgroupContext.class); 6521 } 6522 public ColgroupContext colgroup(int i) { 6523 return getRuleContext(ColgroupContext.class,i); 6524 } 6525 public List<DtContext> dt() { 6526 return getRuleContexts(DtContext.class); 6527 } 6528 public DtContext dt(int i) { 6529 return getRuleContext(DtContext.class,i); 6530 } 6531 public List<HeadContext> head() { 6532 return getRuleContexts(HeadContext.class); 6533 } 6534 public HeadContext head(int i) { 6535 return getRuleContext(HeadContext.class,i); 6536 } 6537 public List<HtmlContext> html() { 6538 return getRuleContexts(HtmlContext.class); 6539 } 6540 public HtmlContext html(int i) { 6541 return getRuleContext(HtmlContext.class,i); 6542 } 6543 public List<OptionContext> option() { 6544 return getRuleContexts(OptionContext.class); 6545 } 6546 public OptionContext option(int i) { 6547 return getRuleContext(OptionContext.class,i); 6548 } 6549 public List<TbodyContext> tbody() { 6550 return getRuleContexts(TbodyContext.class); 6551 } 6552 public TbodyContext tbody(int i) { 6553 return getRuleContext(TbodyContext.class,i); 6554 } 6555 public List<TheadContext> thead() { 6556 return getRuleContexts(TheadContext.class); 6557 } 6558 public TheadContext thead(int i) { 6559 return getRuleContext(TheadContext.class,i); 6560 } 6561 public List<TfootContext> tfoot() { 6562 return getRuleContexts(TfootContext.class); 6563 } 6564 public TfootContext tfoot(int i) { 6565 return getRuleContext(TfootContext.class,i); 6566 } 6567 public List<PTagOpenContext> pTagOpen() { 6568 return getRuleContexts(PTagOpenContext.class); 6569 } 6570 public PTagOpenContext pTagOpen(int i) { 6571 return getRuleContext(PTagOpenContext.class,i); 6572 } 6573 public List<LiTagOpenContext> liTagOpen() { 6574 return getRuleContexts(LiTagOpenContext.class); 6575 } 6576 public LiTagOpenContext liTagOpen(int i) { 6577 return getRuleContext(LiTagOpenContext.class,i); 6578 } 6579 public List<TrTagOpenContext> trTagOpen() { 6580 return getRuleContexts(TrTagOpenContext.class); 6581 } 6582 public TrTagOpenContext trTagOpen(int i) { 6583 return getRuleContext(TrTagOpenContext.class,i); 6584 } 6585 public List<TdTagOpenContext> tdTagOpen() { 6586 return getRuleContexts(TdTagOpenContext.class); 6587 } 6588 public TdTagOpenContext tdTagOpen(int i) { 6589 return getRuleContext(TdTagOpenContext.class,i); 6590 } 6591 public List<ThTagOpenContext> thTagOpen() { 6592 return getRuleContexts(ThTagOpenContext.class); 6593 } 6594 public ThTagOpenContext thTagOpen(int i) { 6595 return getRuleContext(ThTagOpenContext.class,i); 6596 } 6597 public List<BodyTagOpenContext> bodyTagOpen() { 6598 return getRuleContexts(BodyTagOpenContext.class); 6599 } 6600 public BodyTagOpenContext bodyTagOpen(int i) { 6601 return getRuleContext(BodyTagOpenContext.class,i); 6602 } 6603 public List<ColgroupTagOpenContext> colgroupTagOpen() { 6604 return getRuleContexts(ColgroupTagOpenContext.class); 6605 } 6606 public ColgroupTagOpenContext colgroupTagOpen(int i) { 6607 return getRuleContext(ColgroupTagOpenContext.class,i); 6608 } 6609 public List<DtTagOpenContext> dtTagOpen() { 6610 return getRuleContexts(DtTagOpenContext.class); 6611 } 6612 public DtTagOpenContext dtTagOpen(int i) { 6613 return getRuleContext(DtTagOpenContext.class,i); 6614 } 6615 public List<HeadTagOpenContext> headTagOpen() { 6616 return getRuleContexts(HeadTagOpenContext.class); 6617 } 6618 public HeadTagOpenContext headTagOpen(int i) { 6619 return getRuleContext(HeadTagOpenContext.class,i); 6620 } 6621 public List<HtmlTagOpenContext> htmlTagOpen() { 6622 return getRuleContexts(HtmlTagOpenContext.class); 6623 } 6624 public HtmlTagOpenContext htmlTagOpen(int i) { 6625 return getRuleContext(HtmlTagOpenContext.class,i); 6626 } 6627 public List<OptionTagOpenContext> optionTagOpen() { 6628 return getRuleContexts(OptionTagOpenContext.class); 6629 } 6630 public OptionTagOpenContext optionTagOpen(int i) { 6631 return getRuleContext(OptionTagOpenContext.class,i); 6632 } 6633 public List<TbodyTagOpenContext> tbodyTagOpen() { 6634 return getRuleContexts(TbodyTagOpenContext.class); 6635 } 6636 public TbodyTagOpenContext tbodyTagOpen(int i) { 6637 return getRuleContext(TbodyTagOpenContext.class,i); 6638 } 6639 public List<TheadTagOpenContext> theadTagOpen() { 6640 return getRuleContexts(TheadTagOpenContext.class); 6641 } 6642 public TheadTagOpenContext theadTagOpen(int i) { 6643 return getRuleContext(TheadTagOpenContext.class,i); 6644 } 6645 public List<TfootTagOpenContext> tfootTagOpen() { 6646 return getRuleContexts(TfootTagOpenContext.class); 6647 } 6648 public TfootTagOpenContext tfootTagOpen(int i) { 6649 return getRuleContext(TfootTagOpenContext.class,i); 6650 } 6651 public List<HtmlCommentContext> htmlComment() { 6652 return getRuleContexts(HtmlCommentContext.class); 6653 } 6654 public HtmlCommentContext htmlComment(int i) { 6655 return getRuleContext(HtmlCommentContext.class,i); 6656 } 6657 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 6658 public TerminalNode CDATA(int i) { 6659 return getToken(JavadocParser.CDATA, i); 6660 } 6661 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6662 public TerminalNode NEWLINE(int i) { 6663 return getToken(JavadocParser.NEWLINE, i); 6664 } 6665 public List<TextContext> text() { 6666 return getRuleContexts(TextContext.class); 6667 } 6668 public TextContext text(int i) { 6669 return getRuleContext(TextContext.class,i); 6670 } 6671 public List<JavadocInlineTagContext> javadocInlineTag() { 6672 return getRuleContexts(JavadocInlineTagContext.class); 6673 } 6674 public JavadocInlineTagContext javadocInlineTag(int i) { 6675 return getRuleContext(JavadocInlineTagContext.class,i); 6676 } 6677 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6678 public TerminalNode LEADING_ASTERISK(int i) { 6679 return getToken(JavadocParser.LEADING_ASTERISK, i); 6680 } 6681 public DdContext(ParserRuleContext parent, int invokingState) { 6682 super(parent, invokingState); 6683 } 6684 @Override public int getRuleIndex() { return RULE_dd; } 6685 @Override 6686 public void enterRule(ParseTreeListener listener) { 6687 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDd(this); 6688 } 6689 @Override 6690 public void exitRule(ParseTreeListener listener) { 6691 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDd(this); 6692 } 6693 @Override 6694 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6695 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDd(this); 6696 else return visitor.visitChildren(this); 6697 } 6698 } 6699 6700 public final DdContext dd() throws RecognitionException { 6701 DdContext _localctx = new DdContext(_ctx, getState()); 6702 enterRule(_localctx, 58, RULE_dd); 6703 try { 6704 int _alt; 6705 enterOuterAlt(_localctx, 1); 6706 { 6707 setState(813); 6708 ddTagOpen(); 6709 setState(853); 6710 _errHandler.sync(this); 6711 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6712 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6713 if ( _alt==1 ) { 6714 { 6715 setState(851); 6716 _errHandler.sync(this); 6717 switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { 6718 case 1: 6719 { 6720 setState(814); 6721 htmlTag(); 6722 } 6723 break; 6724 case 2: 6725 { 6726 setState(815); 6727 singletonTag(); 6728 } 6729 break; 6730 case 3: 6731 { 6732 setState(816); 6733 paragraph(); 6734 } 6735 break; 6736 case 4: 6737 { 6738 setState(817); 6739 li(); 6740 } 6741 break; 6742 case 5: 6743 { 6744 setState(818); 6745 tr(); 6746 } 6747 break; 6748 case 6: 6749 { 6750 setState(819); 6751 td(); 6752 } 6753 break; 6754 case 7: 6755 { 6756 setState(820); 6757 th(); 6758 } 6759 break; 6760 case 8: 6761 { 6762 setState(821); 6763 body(); 6764 } 6765 break; 6766 case 9: 6767 { 6768 setState(822); 6769 colgroup(); 6770 } 6771 break; 6772 case 10: 6773 { 6774 setState(823); 6775 dt(); 6776 } 6777 break; 6778 case 11: 6779 { 6780 setState(824); 6781 head(); 6782 } 6783 break; 6784 case 12: 6785 { 6786 setState(825); 6787 html(); 6788 } 6789 break; 6790 case 13: 6791 { 6792 setState(826); 6793 option(); 6794 } 6795 break; 6796 case 14: 6797 { 6798 setState(827); 6799 tbody(); 6800 } 6801 break; 6802 case 15: 6803 { 6804 setState(828); 6805 thead(); 6806 } 6807 break; 6808 case 16: 6809 { 6810 setState(829); 6811 tfoot(); 6812 } 6813 break; 6814 case 17: 6815 { 6816 setState(830); 6817 pTagOpen(); 6818 } 6819 break; 6820 case 18: 6821 { 6822 setState(831); 6823 liTagOpen(); 6824 } 6825 break; 6826 case 19: 6827 { 6828 setState(832); 6829 trTagOpen(); 6830 } 6831 break; 6832 case 20: 6833 { 6834 setState(833); 6835 tdTagOpen(); 6836 } 6837 break; 6838 case 21: 6839 { 6840 setState(834); 6841 thTagOpen(); 6842 } 6843 break; 6844 case 22: 6845 { 6846 setState(835); 6847 bodyTagOpen(); 6848 } 6849 break; 6850 case 23: 6851 { 6852 setState(836); 6853 colgroupTagOpen(); 6854 } 6855 break; 6856 case 24: 6857 { 6858 setState(837); 6859 dtTagOpen(); 6860 } 6861 break; 6862 case 25: 6863 { 6864 setState(838); 6865 headTagOpen(); 6866 } 6867 break; 6868 case 26: 6869 { 6870 setState(839); 6871 htmlTagOpen(); 6872 } 6873 break; 6874 case 27: 6875 { 6876 setState(840); 6877 optionTagOpen(); 6878 } 6879 break; 6880 case 28: 6881 { 6882 setState(841); 6883 tbodyTagOpen(); 6884 } 6885 break; 6886 case 29: 6887 { 6888 setState(842); 6889 theadTagOpen(); 6890 } 6891 break; 6892 case 30: 6893 { 6894 setState(843); 6895 tfootTagOpen(); 6896 } 6897 break; 6898 case 31: 6899 { 6900 { 6901 setState(844); 6902 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6903 setState(845); 6904 match(LEADING_ASTERISK); 6905 } 6906 } 6907 break; 6908 case 32: 6909 { 6910 setState(846); 6911 htmlComment(); 6912 } 6913 break; 6914 case 33: 6915 { 6916 setState(847); 6917 match(CDATA); 6918 } 6919 break; 6920 case 34: 6921 { 6922 setState(848); 6923 match(NEWLINE); 6924 } 6925 break; 6926 case 35: 6927 { 6928 setState(849); 6929 text(); 6930 } 6931 break; 6932 case 36: 6933 { 6934 setState(850); 6935 javadocInlineTag(); 6936 } 6937 break; 6938 } 6939 } 6940 } 6941 setState(855); 6942 _errHandler.sync(this); 6943 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6944 } 6945 setState(856); 6946 ddTagClose(); 6947 } 6948 } 6949 catch (RecognitionException re) { 6950 _localctx.exception = re; 6951 _errHandler.reportError(this, re); 6952 _errHandler.recover(this, re); 6953 } 6954 finally { 6955 exitRule(); 6956 } 6957 return _localctx; 6958 } 6959 6960 public static class DtTagOpenContext extends ParserRuleContext { 6961 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6962 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 6963 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6964 public List<AttributeContext> attribute() { 6965 return getRuleContexts(AttributeContext.class); 6966 } 6967 public AttributeContext attribute(int i) { 6968 return getRuleContext(AttributeContext.class,i); 6969 } 6970 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6971 public TerminalNode NEWLINE(int i) { 6972 return getToken(JavadocParser.NEWLINE, i); 6973 } 6974 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6975 public TerminalNode LEADING_ASTERISK(int i) { 6976 return getToken(JavadocParser.LEADING_ASTERISK, i); 6977 } 6978 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6979 public TerminalNode WS(int i) { 6980 return getToken(JavadocParser.WS, i); 6981 } 6982 public DtTagOpenContext(ParserRuleContext parent, int invokingState) { 6983 super(parent, invokingState); 6984 } 6985 @Override public int getRuleIndex() { return RULE_dtTagOpen; } 6986 @Override 6987 public void enterRule(ParseTreeListener listener) { 6988 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagOpen(this); 6989 } 6990 @Override 6991 public void exitRule(ParseTreeListener listener) { 6992 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagOpen(this); 6993 } 6994 @Override 6995 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6996 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagOpen(this); 6997 else return visitor.visitChildren(this); 6998 } 6999 } 7000 7001 public final DtTagOpenContext dtTagOpen() throws RecognitionException { 7002 DtTagOpenContext _localctx = new DtTagOpenContext(_ctx, getState()); 7003 enterRule(_localctx, 60, RULE_dtTagOpen); 7004 int _la; 7005 try { 7006 enterOuterAlt(_localctx, 1); 7007 { 7008 setState(858); 7009 match(OPEN); 7010 setState(859); 7011 match(DT_HTML_TAG_NAME); 7012 setState(866); 7013 _errHandler.sync(this); 7014 _la = _input.LA(1); 7015 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 7016 { 7017 setState(864); 7018 _errHandler.sync(this); 7019 switch (_input.LA(1)) { 7020 case HTML_TAG_NAME: 7021 { 7022 setState(860); 7023 attribute(); 7024 } 7025 break; 7026 case NEWLINE: 7027 { 7028 setState(861); 7029 match(NEWLINE); 7030 } 7031 break; 7032 case LEADING_ASTERISK: 7033 { 7034 setState(862); 7035 match(LEADING_ASTERISK); 7036 } 7037 break; 7038 case WS: 7039 { 7040 setState(863); 7041 match(WS); 7042 } 7043 break; 7044 default: 7045 throw new NoViableAltException(this); 7046 } 7047 } 7048 setState(868); 7049 _errHandler.sync(this); 7050 _la = _input.LA(1); 7051 } 7052 setState(869); 7053 match(CLOSE); 7054 } 7055 } 7056 catch (RecognitionException re) { 7057 _localctx.exception = re; 7058 _errHandler.reportError(this, re); 7059 _errHandler.recover(this, re); 7060 } 7061 finally { 7062 exitRule(); 7063 } 7064 return _localctx; 7065 } 7066 7067 public static class DtTagCloseContext extends ParserRuleContext { 7068 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7069 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7070 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 7071 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7072 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7073 public TerminalNode NEWLINE(int i) { 7074 return getToken(JavadocParser.NEWLINE, i); 7075 } 7076 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7077 public TerminalNode LEADING_ASTERISK(int i) { 7078 return getToken(JavadocParser.LEADING_ASTERISK, i); 7079 } 7080 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7081 public TerminalNode WS(int i) { 7082 return getToken(JavadocParser.WS, i); 7083 } 7084 public DtTagCloseContext(ParserRuleContext parent, int invokingState) { 7085 super(parent, invokingState); 7086 } 7087 @Override public int getRuleIndex() { return RULE_dtTagClose; } 7088 @Override 7089 public void enterRule(ParseTreeListener listener) { 7090 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagClose(this); 7091 } 7092 @Override 7093 public void exitRule(ParseTreeListener listener) { 7094 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagClose(this); 7095 } 7096 @Override 7097 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7098 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagClose(this); 7099 else return visitor.visitChildren(this); 7100 } 7101 } 7102 7103 public final DtTagCloseContext dtTagClose() throws RecognitionException { 7104 DtTagCloseContext _localctx = new DtTagCloseContext(_ctx, getState()); 7105 enterRule(_localctx, 62, RULE_dtTagClose); 7106 int _la; 7107 try { 7108 enterOuterAlt(_localctx, 1); 7109 { 7110 setState(871); 7111 match(OPEN); 7112 setState(872); 7113 match(SLASH); 7114 setState(873); 7115 match(DT_HTML_TAG_NAME); 7116 setState(877); 7117 _errHandler.sync(this); 7118 _la = _input.LA(1); 7119 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7120 { 7121 { 7122 setState(874); 7123 _la = _input.LA(1); 7124 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7125 _errHandler.recoverInline(this); 7126 } 7127 else { 7128 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 7129 _errHandler.reportMatch(this); 7130 consume(); 7131 } 7132 } 7133 } 7134 setState(879); 7135 _errHandler.sync(this); 7136 _la = _input.LA(1); 7137 } 7138 setState(880); 7139 match(CLOSE); 7140 } 7141 } 7142 catch (RecognitionException re) { 7143 _localctx.exception = re; 7144 _errHandler.reportError(this, re); 7145 _errHandler.recover(this, re); 7146 } 7147 finally { 7148 exitRule(); 7149 } 7150 return _localctx; 7151 } 7152 7153 public static class DtContext extends ParserRuleContext { 7154 public DtTagOpenContext dtTagOpen() { 7155 return getRuleContext(DtTagOpenContext.class,0); 7156 } 7157 public DtTagCloseContext dtTagClose() { 7158 return getRuleContext(DtTagCloseContext.class,0); 7159 } 7160 public List<HtmlTagContext> htmlTag() { 7161 return getRuleContexts(HtmlTagContext.class); 7162 } 7163 public HtmlTagContext htmlTag(int i) { 7164 return getRuleContext(HtmlTagContext.class,i); 7165 } 7166 public List<SingletonTagContext> singletonTag() { 7167 return getRuleContexts(SingletonTagContext.class); 7168 } 7169 public SingletonTagContext singletonTag(int i) { 7170 return getRuleContext(SingletonTagContext.class,i); 7171 } 7172 public List<ParagraphContext> paragraph() { 7173 return getRuleContexts(ParagraphContext.class); 7174 } 7175 public ParagraphContext paragraph(int i) { 7176 return getRuleContext(ParagraphContext.class,i); 7177 } 7178 public List<LiContext> li() { 7179 return getRuleContexts(LiContext.class); 7180 } 7181 public LiContext li(int i) { 7182 return getRuleContext(LiContext.class,i); 7183 } 7184 public List<TrContext> tr() { 7185 return getRuleContexts(TrContext.class); 7186 } 7187 public TrContext tr(int i) { 7188 return getRuleContext(TrContext.class,i); 7189 } 7190 public List<TdContext> td() { 7191 return getRuleContexts(TdContext.class); 7192 } 7193 public TdContext td(int i) { 7194 return getRuleContext(TdContext.class,i); 7195 } 7196 public List<ThContext> th() { 7197 return getRuleContexts(ThContext.class); 7198 } 7199 public ThContext th(int i) { 7200 return getRuleContext(ThContext.class,i); 7201 } 7202 public List<BodyContext> body() { 7203 return getRuleContexts(BodyContext.class); 7204 } 7205 public BodyContext body(int i) { 7206 return getRuleContext(BodyContext.class,i); 7207 } 7208 public List<ColgroupContext> colgroup() { 7209 return getRuleContexts(ColgroupContext.class); 7210 } 7211 public ColgroupContext colgroup(int i) { 7212 return getRuleContext(ColgroupContext.class,i); 7213 } 7214 public List<DdContext> dd() { 7215 return getRuleContexts(DdContext.class); 7216 } 7217 public DdContext dd(int i) { 7218 return getRuleContext(DdContext.class,i); 7219 } 7220 public List<HeadContext> head() { 7221 return getRuleContexts(HeadContext.class); 7222 } 7223 public HeadContext head(int i) { 7224 return getRuleContext(HeadContext.class,i); 7225 } 7226 public List<HtmlContext> html() { 7227 return getRuleContexts(HtmlContext.class); 7228 } 7229 public HtmlContext html(int i) { 7230 return getRuleContext(HtmlContext.class,i); 7231 } 7232 public List<OptionContext> option() { 7233 return getRuleContexts(OptionContext.class); 7234 } 7235 public OptionContext option(int i) { 7236 return getRuleContext(OptionContext.class,i); 7237 } 7238 public List<TbodyContext> tbody() { 7239 return getRuleContexts(TbodyContext.class); 7240 } 7241 public TbodyContext tbody(int i) { 7242 return getRuleContext(TbodyContext.class,i); 7243 } 7244 public List<TheadContext> thead() { 7245 return getRuleContexts(TheadContext.class); 7246 } 7247 public TheadContext thead(int i) { 7248 return getRuleContext(TheadContext.class,i); 7249 } 7250 public List<TfootContext> tfoot() { 7251 return getRuleContexts(TfootContext.class); 7252 } 7253 public TfootContext tfoot(int i) { 7254 return getRuleContext(TfootContext.class,i); 7255 } 7256 public List<PTagOpenContext> pTagOpen() { 7257 return getRuleContexts(PTagOpenContext.class); 7258 } 7259 public PTagOpenContext pTagOpen(int i) { 7260 return getRuleContext(PTagOpenContext.class,i); 7261 } 7262 public List<LiTagOpenContext> liTagOpen() { 7263 return getRuleContexts(LiTagOpenContext.class); 7264 } 7265 public LiTagOpenContext liTagOpen(int i) { 7266 return getRuleContext(LiTagOpenContext.class,i); 7267 } 7268 public List<TrTagOpenContext> trTagOpen() { 7269 return getRuleContexts(TrTagOpenContext.class); 7270 } 7271 public TrTagOpenContext trTagOpen(int i) { 7272 return getRuleContext(TrTagOpenContext.class,i); 7273 } 7274 public List<TdTagOpenContext> tdTagOpen() { 7275 return getRuleContexts(TdTagOpenContext.class); 7276 } 7277 public TdTagOpenContext tdTagOpen(int i) { 7278 return getRuleContext(TdTagOpenContext.class,i); 7279 } 7280 public List<ThTagOpenContext> thTagOpen() { 7281 return getRuleContexts(ThTagOpenContext.class); 7282 } 7283 public ThTagOpenContext thTagOpen(int i) { 7284 return getRuleContext(ThTagOpenContext.class,i); 7285 } 7286 public List<BodyTagOpenContext> bodyTagOpen() { 7287 return getRuleContexts(BodyTagOpenContext.class); 7288 } 7289 public BodyTagOpenContext bodyTagOpen(int i) { 7290 return getRuleContext(BodyTagOpenContext.class,i); 7291 } 7292 public List<ColgroupTagOpenContext> colgroupTagOpen() { 7293 return getRuleContexts(ColgroupTagOpenContext.class); 7294 } 7295 public ColgroupTagOpenContext colgroupTagOpen(int i) { 7296 return getRuleContext(ColgroupTagOpenContext.class,i); 7297 } 7298 public List<DdTagOpenContext> ddTagOpen() { 7299 return getRuleContexts(DdTagOpenContext.class); 7300 } 7301 public DdTagOpenContext ddTagOpen(int i) { 7302 return getRuleContext(DdTagOpenContext.class,i); 7303 } 7304 public List<HeadTagOpenContext> headTagOpen() { 7305 return getRuleContexts(HeadTagOpenContext.class); 7306 } 7307 public HeadTagOpenContext headTagOpen(int i) { 7308 return getRuleContext(HeadTagOpenContext.class,i); 7309 } 7310 public List<HtmlTagOpenContext> htmlTagOpen() { 7311 return getRuleContexts(HtmlTagOpenContext.class); 7312 } 7313 public HtmlTagOpenContext htmlTagOpen(int i) { 7314 return getRuleContext(HtmlTagOpenContext.class,i); 7315 } 7316 public List<OptionTagOpenContext> optionTagOpen() { 7317 return getRuleContexts(OptionTagOpenContext.class); 7318 } 7319 public OptionTagOpenContext optionTagOpen(int i) { 7320 return getRuleContext(OptionTagOpenContext.class,i); 7321 } 7322 public List<TbodyTagOpenContext> tbodyTagOpen() { 7323 return getRuleContexts(TbodyTagOpenContext.class); 7324 } 7325 public TbodyTagOpenContext tbodyTagOpen(int i) { 7326 return getRuleContext(TbodyTagOpenContext.class,i); 7327 } 7328 public List<TheadTagOpenContext> theadTagOpen() { 7329 return getRuleContexts(TheadTagOpenContext.class); 7330 } 7331 public TheadTagOpenContext theadTagOpen(int i) { 7332 return getRuleContext(TheadTagOpenContext.class,i); 7333 } 7334 public List<TfootTagOpenContext> tfootTagOpen() { 7335 return getRuleContexts(TfootTagOpenContext.class); 7336 } 7337 public TfootTagOpenContext tfootTagOpen(int i) { 7338 return getRuleContext(TfootTagOpenContext.class,i); 7339 } 7340 public List<HtmlCommentContext> htmlComment() { 7341 return getRuleContexts(HtmlCommentContext.class); 7342 } 7343 public HtmlCommentContext htmlComment(int i) { 7344 return getRuleContext(HtmlCommentContext.class,i); 7345 } 7346 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 7347 public TerminalNode CDATA(int i) { 7348 return getToken(JavadocParser.CDATA, i); 7349 } 7350 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7351 public TerminalNode NEWLINE(int i) { 7352 return getToken(JavadocParser.NEWLINE, i); 7353 } 7354 public List<TextContext> text() { 7355 return getRuleContexts(TextContext.class); 7356 } 7357 public TextContext text(int i) { 7358 return getRuleContext(TextContext.class,i); 7359 } 7360 public List<JavadocInlineTagContext> javadocInlineTag() { 7361 return getRuleContexts(JavadocInlineTagContext.class); 7362 } 7363 public JavadocInlineTagContext javadocInlineTag(int i) { 7364 return getRuleContext(JavadocInlineTagContext.class,i); 7365 } 7366 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7367 public TerminalNode LEADING_ASTERISK(int i) { 7368 return getToken(JavadocParser.LEADING_ASTERISK, i); 7369 } 7370 public DtContext(ParserRuleContext parent, int invokingState) { 7371 super(parent, invokingState); 7372 } 7373 @Override public int getRuleIndex() { return RULE_dt; } 7374 @Override 7375 public void enterRule(ParseTreeListener listener) { 7376 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDt(this); 7377 } 7378 @Override 7379 public void exitRule(ParseTreeListener listener) { 7380 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDt(this); 7381 } 7382 @Override 7383 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7384 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDt(this); 7385 else return visitor.visitChildren(this); 7386 } 7387 } 7388 7389 public final DtContext dt() throws RecognitionException { 7390 DtContext _localctx = new DtContext(_ctx, getState()); 7391 enterRule(_localctx, 64, RULE_dt); 7392 try { 7393 int _alt; 7394 enterOuterAlt(_localctx, 1); 7395 { 7396 setState(882); 7397 dtTagOpen(); 7398 setState(922); 7399 _errHandler.sync(this); 7400 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 7401 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 7402 if ( _alt==1 ) { 7403 { 7404 setState(920); 7405 _errHandler.sync(this); 7406 switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { 7407 case 1: 7408 { 7409 setState(883); 7410 htmlTag(); 7411 } 7412 break; 7413 case 2: 7414 { 7415 setState(884); 7416 singletonTag(); 7417 } 7418 break; 7419 case 3: 7420 { 7421 setState(885); 7422 paragraph(); 7423 } 7424 break; 7425 case 4: 7426 { 7427 setState(886); 7428 li(); 7429 } 7430 break; 7431 case 5: 7432 { 7433 setState(887); 7434 tr(); 7435 } 7436 break; 7437 case 6: 7438 { 7439 setState(888); 7440 td(); 7441 } 7442 break; 7443 case 7: 7444 { 7445 setState(889); 7446 th(); 7447 } 7448 break; 7449 case 8: 7450 { 7451 setState(890); 7452 body(); 7453 } 7454 break; 7455 case 9: 7456 { 7457 setState(891); 7458 colgroup(); 7459 } 7460 break; 7461 case 10: 7462 { 7463 setState(892); 7464 dd(); 7465 } 7466 break; 7467 case 11: 7468 { 7469 setState(893); 7470 head(); 7471 } 7472 break; 7473 case 12: 7474 { 7475 setState(894); 7476 html(); 7477 } 7478 break; 7479 case 13: 7480 { 7481 setState(895); 7482 option(); 7483 } 7484 break; 7485 case 14: 7486 { 7487 setState(896); 7488 tbody(); 7489 } 7490 break; 7491 case 15: 7492 { 7493 setState(897); 7494 thead(); 7495 } 7496 break; 7497 case 16: 7498 { 7499 setState(898); 7500 tfoot(); 7501 } 7502 break; 7503 case 17: 7504 { 7505 setState(899); 7506 pTagOpen(); 7507 } 7508 break; 7509 case 18: 7510 { 7511 setState(900); 7512 liTagOpen(); 7513 } 7514 break; 7515 case 19: 7516 { 7517 setState(901); 7518 trTagOpen(); 7519 } 7520 break; 7521 case 20: 7522 { 7523 setState(902); 7524 tdTagOpen(); 7525 } 7526 break; 7527 case 21: 7528 { 7529 setState(903); 7530 thTagOpen(); 7531 } 7532 break; 7533 case 22: 7534 { 7535 setState(904); 7536 bodyTagOpen(); 7537 } 7538 break; 7539 case 23: 7540 { 7541 setState(905); 7542 colgroupTagOpen(); 7543 } 7544 break; 7545 case 24: 7546 { 7547 setState(906); 7548 ddTagOpen(); 7549 } 7550 break; 7551 case 25: 7552 { 7553 setState(907); 7554 headTagOpen(); 7555 } 7556 break; 7557 case 26: 7558 { 7559 setState(908); 7560 htmlTagOpen(); 7561 } 7562 break; 7563 case 27: 7564 { 7565 setState(909); 7566 optionTagOpen(); 7567 } 7568 break; 7569 case 28: 7570 { 7571 setState(910); 7572 tbodyTagOpen(); 7573 } 7574 break; 7575 case 29: 7576 { 7577 setState(911); 7578 theadTagOpen(); 7579 } 7580 break; 7581 case 30: 7582 { 7583 setState(912); 7584 tfootTagOpen(); 7585 } 7586 break; 7587 case 31: 7588 { 7589 { 7590 setState(913); 7591 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 7592 setState(914); 7593 match(LEADING_ASTERISK); 7594 } 7595 } 7596 break; 7597 case 32: 7598 { 7599 setState(915); 7600 htmlComment(); 7601 } 7602 break; 7603 case 33: 7604 { 7605 setState(916); 7606 match(CDATA); 7607 } 7608 break; 7609 case 34: 7610 { 7611 setState(917); 7612 match(NEWLINE); 7613 } 7614 break; 7615 case 35: 7616 { 7617 setState(918); 7618 text(); 7619 } 7620 break; 7621 case 36: 7622 { 7623 setState(919); 7624 javadocInlineTag(); 7625 } 7626 break; 7627 } 7628 } 7629 } 7630 setState(924); 7631 _errHandler.sync(this); 7632 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 7633 } 7634 setState(925); 7635 dtTagClose(); 7636 } 7637 } 7638 catch (RecognitionException re) { 7639 _localctx.exception = re; 7640 _errHandler.reportError(this, re); 7641 _errHandler.recover(this, re); 7642 } 7643 finally { 7644 exitRule(); 7645 } 7646 return _localctx; 7647 } 7648 7649 public static class HeadTagOpenContext extends ParserRuleContext { 7650 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7651 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7652 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7653 public List<AttributeContext> attribute() { 7654 return getRuleContexts(AttributeContext.class); 7655 } 7656 public AttributeContext attribute(int i) { 7657 return getRuleContext(AttributeContext.class,i); 7658 } 7659 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7660 public TerminalNode NEWLINE(int i) { 7661 return getToken(JavadocParser.NEWLINE, i); 7662 } 7663 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7664 public TerminalNode LEADING_ASTERISK(int i) { 7665 return getToken(JavadocParser.LEADING_ASTERISK, i); 7666 } 7667 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7668 public TerminalNode WS(int i) { 7669 return getToken(JavadocParser.WS, i); 7670 } 7671 public HeadTagOpenContext(ParserRuleContext parent, int invokingState) { 7672 super(parent, invokingState); 7673 } 7674 @Override public int getRuleIndex() { return RULE_headTagOpen; } 7675 @Override 7676 public void enterRule(ParseTreeListener listener) { 7677 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagOpen(this); 7678 } 7679 @Override 7680 public void exitRule(ParseTreeListener listener) { 7681 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagOpen(this); 7682 } 7683 @Override 7684 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7685 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagOpen(this); 7686 else return visitor.visitChildren(this); 7687 } 7688 } 7689 7690 public final HeadTagOpenContext headTagOpen() throws RecognitionException { 7691 HeadTagOpenContext _localctx = new HeadTagOpenContext(_ctx, getState()); 7692 enterRule(_localctx, 66, RULE_headTagOpen); 7693 int _la; 7694 try { 7695 enterOuterAlt(_localctx, 1); 7696 { 7697 setState(927); 7698 match(OPEN); 7699 setState(928); 7700 match(HEAD_HTML_TAG_NAME); 7701 setState(935); 7702 _errHandler.sync(this); 7703 _la = _input.LA(1); 7704 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 7705 { 7706 setState(933); 7707 _errHandler.sync(this); 7708 switch (_input.LA(1)) { 7709 case HTML_TAG_NAME: 7710 { 7711 setState(929); 7712 attribute(); 7713 } 7714 break; 7715 case NEWLINE: 7716 { 7717 setState(930); 7718 match(NEWLINE); 7719 } 7720 break; 7721 case LEADING_ASTERISK: 7722 { 7723 setState(931); 7724 match(LEADING_ASTERISK); 7725 } 7726 break; 7727 case WS: 7728 { 7729 setState(932); 7730 match(WS); 7731 } 7732 break; 7733 default: 7734 throw new NoViableAltException(this); 7735 } 7736 } 7737 setState(937); 7738 _errHandler.sync(this); 7739 _la = _input.LA(1); 7740 } 7741 setState(938); 7742 match(CLOSE); 7743 } 7744 } 7745 catch (RecognitionException re) { 7746 _localctx.exception = re; 7747 _errHandler.reportError(this, re); 7748 _errHandler.recover(this, re); 7749 } 7750 finally { 7751 exitRule(); 7752 } 7753 return _localctx; 7754 } 7755 7756 public static class HeadTagCloseContext extends ParserRuleContext { 7757 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7758 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7759 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7760 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7761 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7762 public TerminalNode NEWLINE(int i) { 7763 return getToken(JavadocParser.NEWLINE, i); 7764 } 7765 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7766 public TerminalNode LEADING_ASTERISK(int i) { 7767 return getToken(JavadocParser.LEADING_ASTERISK, i); 7768 } 7769 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7770 public TerminalNode WS(int i) { 7771 return getToken(JavadocParser.WS, i); 7772 } 7773 public HeadTagCloseContext(ParserRuleContext parent, int invokingState) { 7774 super(parent, invokingState); 7775 } 7776 @Override public int getRuleIndex() { return RULE_headTagClose; } 7777 @Override 7778 public void enterRule(ParseTreeListener listener) { 7779 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagClose(this); 7780 } 7781 @Override 7782 public void exitRule(ParseTreeListener listener) { 7783 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagClose(this); 7784 } 7785 @Override 7786 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7787 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagClose(this); 7788 else return visitor.visitChildren(this); 7789 } 7790 } 7791 7792 public final HeadTagCloseContext headTagClose() throws RecognitionException { 7793 HeadTagCloseContext _localctx = new HeadTagCloseContext(_ctx, getState()); 7794 enterRule(_localctx, 68, RULE_headTagClose); 7795 int _la; 7796 try { 7797 enterOuterAlt(_localctx, 1); 7798 { 7799 setState(940); 7800 match(OPEN); 7801 setState(941); 7802 match(SLASH); 7803 setState(942); 7804 match(HEAD_HTML_TAG_NAME); 7805 setState(946); 7806 _errHandler.sync(this); 7807 _la = _input.LA(1); 7808 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7809 { 7810 { 7811 setState(943); 7812 _la = _input.LA(1); 7813 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7814 _errHandler.recoverInline(this); 7815 } 7816 else { 7817 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 7818 _errHandler.reportMatch(this); 7819 consume(); 7820 } 7821 } 7822 } 7823 setState(948); 7824 _errHandler.sync(this); 7825 _la = _input.LA(1); 7826 } 7827 setState(949); 7828 match(CLOSE); 7829 } 7830 } 7831 catch (RecognitionException re) { 7832 _localctx.exception = re; 7833 _errHandler.reportError(this, re); 7834 _errHandler.recover(this, re); 7835 } 7836 finally { 7837 exitRule(); 7838 } 7839 return _localctx; 7840 } 7841 7842 public static class HeadContext extends ParserRuleContext { 7843 public HeadTagOpenContext headTagOpen() { 7844 return getRuleContext(HeadTagOpenContext.class,0); 7845 } 7846 public HeadTagCloseContext headTagClose() { 7847 return getRuleContext(HeadTagCloseContext.class,0); 7848 } 7849 public List<HtmlTagContext> htmlTag() { 7850 return getRuleContexts(HtmlTagContext.class); 7851 } 7852 public HtmlTagContext htmlTag(int i) { 7853 return getRuleContext(HtmlTagContext.class,i); 7854 } 7855 public List<SingletonTagContext> singletonTag() { 7856 return getRuleContexts(SingletonTagContext.class); 7857 } 7858 public SingletonTagContext singletonTag(int i) { 7859 return getRuleContext(SingletonTagContext.class,i); 7860 } 7861 public List<ParagraphContext> paragraph() { 7862 return getRuleContexts(ParagraphContext.class); 7863 } 7864 public ParagraphContext paragraph(int i) { 7865 return getRuleContext(ParagraphContext.class,i); 7866 } 7867 public List<LiContext> li() { 7868 return getRuleContexts(LiContext.class); 7869 } 7870 public LiContext li(int i) { 7871 return getRuleContext(LiContext.class,i); 7872 } 7873 public List<TrContext> tr() { 7874 return getRuleContexts(TrContext.class); 7875 } 7876 public TrContext tr(int i) { 7877 return getRuleContext(TrContext.class,i); 7878 } 7879 public List<TdContext> td() { 7880 return getRuleContexts(TdContext.class); 7881 } 7882 public TdContext td(int i) { 7883 return getRuleContext(TdContext.class,i); 7884 } 7885 public List<ThContext> th() { 7886 return getRuleContexts(ThContext.class); 7887 } 7888 public ThContext th(int i) { 7889 return getRuleContext(ThContext.class,i); 7890 } 7891 public List<BodyContext> body() { 7892 return getRuleContexts(BodyContext.class); 7893 } 7894 public BodyContext body(int i) { 7895 return getRuleContext(BodyContext.class,i); 7896 } 7897 public List<ColgroupContext> colgroup() { 7898 return getRuleContexts(ColgroupContext.class); 7899 } 7900 public ColgroupContext colgroup(int i) { 7901 return getRuleContext(ColgroupContext.class,i); 7902 } 7903 public List<DdContext> dd() { 7904 return getRuleContexts(DdContext.class); 7905 } 7906 public DdContext dd(int i) { 7907 return getRuleContext(DdContext.class,i); 7908 } 7909 public List<DtContext> dt() { 7910 return getRuleContexts(DtContext.class); 7911 } 7912 public DtContext dt(int i) { 7913 return getRuleContext(DtContext.class,i); 7914 } 7915 public List<HtmlContext> html() { 7916 return getRuleContexts(HtmlContext.class); 7917 } 7918 public HtmlContext html(int i) { 7919 return getRuleContext(HtmlContext.class,i); 7920 } 7921 public List<OptionContext> option() { 7922 return getRuleContexts(OptionContext.class); 7923 } 7924 public OptionContext option(int i) { 7925 return getRuleContext(OptionContext.class,i); 7926 } 7927 public List<TbodyContext> tbody() { 7928 return getRuleContexts(TbodyContext.class); 7929 } 7930 public TbodyContext tbody(int i) { 7931 return getRuleContext(TbodyContext.class,i); 7932 } 7933 public List<TheadContext> thead() { 7934 return getRuleContexts(TheadContext.class); 7935 } 7936 public TheadContext thead(int i) { 7937 return getRuleContext(TheadContext.class,i); 7938 } 7939 public List<TfootContext> tfoot() { 7940 return getRuleContexts(TfootContext.class); 7941 } 7942 public TfootContext tfoot(int i) { 7943 return getRuleContext(TfootContext.class,i); 7944 } 7945 public List<PTagOpenContext> pTagOpen() { 7946 return getRuleContexts(PTagOpenContext.class); 7947 } 7948 public PTagOpenContext pTagOpen(int i) { 7949 return getRuleContext(PTagOpenContext.class,i); 7950 } 7951 public List<LiTagOpenContext> liTagOpen() { 7952 return getRuleContexts(LiTagOpenContext.class); 7953 } 7954 public LiTagOpenContext liTagOpen(int i) { 7955 return getRuleContext(LiTagOpenContext.class,i); 7956 } 7957 public List<TrTagOpenContext> trTagOpen() { 7958 return getRuleContexts(TrTagOpenContext.class); 7959 } 7960 public TrTagOpenContext trTagOpen(int i) { 7961 return getRuleContext(TrTagOpenContext.class,i); 7962 } 7963 public List<TdTagOpenContext> tdTagOpen() { 7964 return getRuleContexts(TdTagOpenContext.class); 7965 } 7966 public TdTagOpenContext tdTagOpen(int i) { 7967 return getRuleContext(TdTagOpenContext.class,i); 7968 } 7969 public List<ThTagOpenContext> thTagOpen() { 7970 return getRuleContexts(ThTagOpenContext.class); 7971 } 7972 public ThTagOpenContext thTagOpen(int i) { 7973 return getRuleContext(ThTagOpenContext.class,i); 7974 } 7975 public List<BodyTagOpenContext> bodyTagOpen() { 7976 return getRuleContexts(BodyTagOpenContext.class); 7977 } 7978 public BodyTagOpenContext bodyTagOpen(int i) { 7979 return getRuleContext(BodyTagOpenContext.class,i); 7980 } 7981 public List<ColgroupTagOpenContext> colgroupTagOpen() { 7982 return getRuleContexts(ColgroupTagOpenContext.class); 7983 } 7984 public ColgroupTagOpenContext colgroupTagOpen(int i) { 7985 return getRuleContext(ColgroupTagOpenContext.class,i); 7986 } 7987 public List<DdTagOpenContext> ddTagOpen() { 7988 return getRuleContexts(DdTagOpenContext.class); 7989 } 7990 public DdTagOpenContext ddTagOpen(int i) { 7991 return getRuleContext(DdTagOpenContext.class,i); 7992 } 7993 public List<DtTagOpenContext> dtTagOpen() { 7994 return getRuleContexts(DtTagOpenContext.class); 7995 } 7996 public DtTagOpenContext dtTagOpen(int i) { 7997 return getRuleContext(DtTagOpenContext.class,i); 7998 } 7999 public List<HtmlTagOpenContext> htmlTagOpen() { 8000 return getRuleContexts(HtmlTagOpenContext.class); 8001 } 8002 public HtmlTagOpenContext htmlTagOpen(int i) { 8003 return getRuleContext(HtmlTagOpenContext.class,i); 8004 } 8005 public List<OptionTagOpenContext> optionTagOpen() { 8006 return getRuleContexts(OptionTagOpenContext.class); 8007 } 8008 public OptionTagOpenContext optionTagOpen(int i) { 8009 return getRuleContext(OptionTagOpenContext.class,i); 8010 } 8011 public List<TbodyTagOpenContext> tbodyTagOpen() { 8012 return getRuleContexts(TbodyTagOpenContext.class); 8013 } 8014 public TbodyTagOpenContext tbodyTagOpen(int i) { 8015 return getRuleContext(TbodyTagOpenContext.class,i); 8016 } 8017 public List<TheadTagOpenContext> theadTagOpen() { 8018 return getRuleContexts(TheadTagOpenContext.class); 8019 } 8020 public TheadTagOpenContext theadTagOpen(int i) { 8021 return getRuleContext(TheadTagOpenContext.class,i); 8022 } 8023 public List<TfootTagOpenContext> tfootTagOpen() { 8024 return getRuleContexts(TfootTagOpenContext.class); 8025 } 8026 public TfootTagOpenContext tfootTagOpen(int i) { 8027 return getRuleContext(TfootTagOpenContext.class,i); 8028 } 8029 public List<HtmlCommentContext> htmlComment() { 8030 return getRuleContexts(HtmlCommentContext.class); 8031 } 8032 public HtmlCommentContext htmlComment(int i) { 8033 return getRuleContext(HtmlCommentContext.class,i); 8034 } 8035 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8036 public TerminalNode CDATA(int i) { 8037 return getToken(JavadocParser.CDATA, i); 8038 } 8039 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8040 public TerminalNode NEWLINE(int i) { 8041 return getToken(JavadocParser.NEWLINE, i); 8042 } 8043 public List<TextContext> text() { 8044 return getRuleContexts(TextContext.class); 8045 } 8046 public TextContext text(int i) { 8047 return getRuleContext(TextContext.class,i); 8048 } 8049 public List<JavadocInlineTagContext> javadocInlineTag() { 8050 return getRuleContexts(JavadocInlineTagContext.class); 8051 } 8052 public JavadocInlineTagContext javadocInlineTag(int i) { 8053 return getRuleContext(JavadocInlineTagContext.class,i); 8054 } 8055 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8056 public TerminalNode LEADING_ASTERISK(int i) { 8057 return getToken(JavadocParser.LEADING_ASTERISK, i); 8058 } 8059 public HeadContext(ParserRuleContext parent, int invokingState) { 8060 super(parent, invokingState); 8061 } 8062 @Override public int getRuleIndex() { return RULE_head; } 8063 @Override 8064 public void enterRule(ParseTreeListener listener) { 8065 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHead(this); 8066 } 8067 @Override 8068 public void exitRule(ParseTreeListener listener) { 8069 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHead(this); 8070 } 8071 @Override 8072 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8073 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHead(this); 8074 else return visitor.visitChildren(this); 8075 } 8076 } 8077 8078 public final HeadContext head() throws RecognitionException { 8079 HeadContext _localctx = new HeadContext(_ctx, getState()); 8080 enterRule(_localctx, 70, RULE_head); 8081 try { 8082 int _alt; 8083 enterOuterAlt(_localctx, 1); 8084 { 8085 setState(951); 8086 headTagOpen(); 8087 setState(991); 8088 _errHandler.sync(this); 8089 _alt = getInterpreter().adaptivePredict(_input,66,_ctx); 8090 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8091 if ( _alt==1 ) { 8092 { 8093 setState(989); 8094 _errHandler.sync(this); 8095 switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) { 8096 case 1: 8097 { 8098 setState(952); 8099 htmlTag(); 8100 } 8101 break; 8102 case 2: 8103 { 8104 setState(953); 8105 singletonTag(); 8106 } 8107 break; 8108 case 3: 8109 { 8110 setState(954); 8111 paragraph(); 8112 } 8113 break; 8114 case 4: 8115 { 8116 setState(955); 8117 li(); 8118 } 8119 break; 8120 case 5: 8121 { 8122 setState(956); 8123 tr(); 8124 } 8125 break; 8126 case 6: 8127 { 8128 setState(957); 8129 td(); 8130 } 8131 break; 8132 case 7: 8133 { 8134 setState(958); 8135 th(); 8136 } 8137 break; 8138 case 8: 8139 { 8140 setState(959); 8141 body(); 8142 } 8143 break; 8144 case 9: 8145 { 8146 setState(960); 8147 colgroup(); 8148 } 8149 break; 8150 case 10: 8151 { 8152 setState(961); 8153 dd(); 8154 } 8155 break; 8156 case 11: 8157 { 8158 setState(962); 8159 dt(); 8160 } 8161 break; 8162 case 12: 8163 { 8164 setState(963); 8165 html(); 8166 } 8167 break; 8168 case 13: 8169 { 8170 setState(964); 8171 option(); 8172 } 8173 break; 8174 case 14: 8175 { 8176 setState(965); 8177 tbody(); 8178 } 8179 break; 8180 case 15: 8181 { 8182 setState(966); 8183 thead(); 8184 } 8185 break; 8186 case 16: 8187 { 8188 setState(967); 8189 tfoot(); 8190 } 8191 break; 8192 case 17: 8193 { 8194 setState(968); 8195 pTagOpen(); 8196 } 8197 break; 8198 case 18: 8199 { 8200 setState(969); 8201 liTagOpen(); 8202 } 8203 break; 8204 case 19: 8205 { 8206 setState(970); 8207 trTagOpen(); 8208 } 8209 break; 8210 case 20: 8211 { 8212 setState(971); 8213 tdTagOpen(); 8214 } 8215 break; 8216 case 21: 8217 { 8218 setState(972); 8219 thTagOpen(); 8220 } 8221 break; 8222 case 22: 8223 { 8224 setState(973); 8225 bodyTagOpen(); 8226 } 8227 break; 8228 case 23: 8229 { 8230 setState(974); 8231 colgroupTagOpen(); 8232 } 8233 break; 8234 case 24: 8235 { 8236 setState(975); 8237 ddTagOpen(); 8238 } 8239 break; 8240 case 25: 8241 { 8242 setState(976); 8243 dtTagOpen(); 8244 } 8245 break; 8246 case 26: 8247 { 8248 setState(977); 8249 htmlTagOpen(); 8250 } 8251 break; 8252 case 27: 8253 { 8254 setState(978); 8255 optionTagOpen(); 8256 } 8257 break; 8258 case 28: 8259 { 8260 setState(979); 8261 tbodyTagOpen(); 8262 } 8263 break; 8264 case 29: 8265 { 8266 setState(980); 8267 theadTagOpen(); 8268 } 8269 break; 8270 case 30: 8271 { 8272 setState(981); 8273 tfootTagOpen(); 8274 } 8275 break; 8276 case 31: 8277 { 8278 { 8279 setState(982); 8280 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8281 setState(983); 8282 match(LEADING_ASTERISK); 8283 } 8284 } 8285 break; 8286 case 32: 8287 { 8288 setState(984); 8289 htmlComment(); 8290 } 8291 break; 8292 case 33: 8293 { 8294 setState(985); 8295 match(CDATA); 8296 } 8297 break; 8298 case 34: 8299 { 8300 setState(986); 8301 match(NEWLINE); 8302 } 8303 break; 8304 case 35: 8305 { 8306 setState(987); 8307 text(); 8308 } 8309 break; 8310 case 36: 8311 { 8312 setState(988); 8313 javadocInlineTag(); 8314 } 8315 break; 8316 } 8317 } 8318 } 8319 setState(993); 8320 _errHandler.sync(this); 8321 _alt = getInterpreter().adaptivePredict(_input,66,_ctx); 8322 } 8323 setState(994); 8324 headTagClose(); 8325 } 8326 } 8327 catch (RecognitionException re) { 8328 _localctx.exception = re; 8329 _errHandler.reportError(this, re); 8330 _errHandler.recover(this, re); 8331 } 8332 finally { 8333 exitRule(); 8334 } 8335 return _localctx; 8336 } 8337 8338 public static class HtmlTagOpenContext extends ParserRuleContext { 8339 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8340 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 8341 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8342 public List<AttributeContext> attribute() { 8343 return getRuleContexts(AttributeContext.class); 8344 } 8345 public AttributeContext attribute(int i) { 8346 return getRuleContext(AttributeContext.class,i); 8347 } 8348 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8349 public TerminalNode NEWLINE(int i) { 8350 return getToken(JavadocParser.NEWLINE, i); 8351 } 8352 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8353 public TerminalNode LEADING_ASTERISK(int i) { 8354 return getToken(JavadocParser.LEADING_ASTERISK, i); 8355 } 8356 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8357 public TerminalNode WS(int i) { 8358 return getToken(JavadocParser.WS, i); 8359 } 8360 public HtmlTagOpenContext(ParserRuleContext parent, int invokingState) { 8361 super(parent, invokingState); 8362 } 8363 @Override public int getRuleIndex() { return RULE_htmlTagOpen; } 8364 @Override 8365 public void enterRule(ParseTreeListener listener) { 8366 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagOpen(this); 8367 } 8368 @Override 8369 public void exitRule(ParseTreeListener listener) { 8370 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagOpen(this); 8371 } 8372 @Override 8373 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8374 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagOpen(this); 8375 else return visitor.visitChildren(this); 8376 } 8377 } 8378 8379 public final HtmlTagOpenContext htmlTagOpen() throws RecognitionException { 8380 HtmlTagOpenContext _localctx = new HtmlTagOpenContext(_ctx, getState()); 8381 enterRule(_localctx, 72, RULE_htmlTagOpen); 8382 int _la; 8383 try { 8384 enterOuterAlt(_localctx, 1); 8385 { 8386 setState(996); 8387 match(OPEN); 8388 setState(997); 8389 match(HTML_HTML_TAG_NAME); 8390 setState(1004); 8391 _errHandler.sync(this); 8392 _la = _input.LA(1); 8393 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 8394 { 8395 setState(1002); 8396 _errHandler.sync(this); 8397 switch (_input.LA(1)) { 8398 case HTML_TAG_NAME: 8399 { 8400 setState(998); 8401 attribute(); 8402 } 8403 break; 8404 case NEWLINE: 8405 { 8406 setState(999); 8407 match(NEWLINE); 8408 } 8409 break; 8410 case LEADING_ASTERISK: 8411 { 8412 setState(1000); 8413 match(LEADING_ASTERISK); 8414 } 8415 break; 8416 case WS: 8417 { 8418 setState(1001); 8419 match(WS); 8420 } 8421 break; 8422 default: 8423 throw new NoViableAltException(this); 8424 } 8425 } 8426 setState(1006); 8427 _errHandler.sync(this); 8428 _la = _input.LA(1); 8429 } 8430 setState(1007); 8431 match(CLOSE); 8432 } 8433 } 8434 catch (RecognitionException re) { 8435 _localctx.exception = re; 8436 _errHandler.reportError(this, re); 8437 _errHandler.recover(this, re); 8438 } 8439 finally { 8440 exitRule(); 8441 } 8442 return _localctx; 8443 } 8444 8445 public static class HtmlTagCloseContext extends ParserRuleContext { 8446 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8447 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 8448 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 8449 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8450 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8451 public TerminalNode NEWLINE(int i) { 8452 return getToken(JavadocParser.NEWLINE, i); 8453 } 8454 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8455 public TerminalNode LEADING_ASTERISK(int i) { 8456 return getToken(JavadocParser.LEADING_ASTERISK, i); 8457 } 8458 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8459 public TerminalNode WS(int i) { 8460 return getToken(JavadocParser.WS, i); 8461 } 8462 public HtmlTagCloseContext(ParserRuleContext parent, int invokingState) { 8463 super(parent, invokingState); 8464 } 8465 @Override public int getRuleIndex() { return RULE_htmlTagClose; } 8466 @Override 8467 public void enterRule(ParseTreeListener listener) { 8468 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagClose(this); 8469 } 8470 @Override 8471 public void exitRule(ParseTreeListener listener) { 8472 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagClose(this); 8473 } 8474 @Override 8475 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8476 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagClose(this); 8477 else return visitor.visitChildren(this); 8478 } 8479 } 8480 8481 public final HtmlTagCloseContext htmlTagClose() throws RecognitionException { 8482 HtmlTagCloseContext _localctx = new HtmlTagCloseContext(_ctx, getState()); 8483 enterRule(_localctx, 74, RULE_htmlTagClose); 8484 int _la; 8485 try { 8486 enterOuterAlt(_localctx, 1); 8487 { 8488 setState(1009); 8489 match(OPEN); 8490 setState(1010); 8491 match(SLASH); 8492 setState(1011); 8493 match(HTML_HTML_TAG_NAME); 8494 setState(1015); 8495 _errHandler.sync(this); 8496 _la = _input.LA(1); 8497 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 8498 { 8499 { 8500 setState(1012); 8501 _la = _input.LA(1); 8502 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 8503 _errHandler.recoverInline(this); 8504 } 8505 else { 8506 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 8507 _errHandler.reportMatch(this); 8508 consume(); 8509 } 8510 } 8511 } 8512 setState(1017); 8513 _errHandler.sync(this); 8514 _la = _input.LA(1); 8515 } 8516 setState(1018); 8517 match(CLOSE); 8518 } 8519 } 8520 catch (RecognitionException re) { 8521 _localctx.exception = re; 8522 _errHandler.reportError(this, re); 8523 _errHandler.recover(this, re); 8524 } 8525 finally { 8526 exitRule(); 8527 } 8528 return _localctx; 8529 } 8530 8531 public static class HtmlContext extends ParserRuleContext { 8532 public HtmlTagOpenContext htmlTagOpen() { 8533 return getRuleContext(HtmlTagOpenContext.class,0); 8534 } 8535 public HtmlTagCloseContext htmlTagClose() { 8536 return getRuleContext(HtmlTagCloseContext.class,0); 8537 } 8538 public List<HtmlTagContext> htmlTag() { 8539 return getRuleContexts(HtmlTagContext.class); 8540 } 8541 public HtmlTagContext htmlTag(int i) { 8542 return getRuleContext(HtmlTagContext.class,i); 8543 } 8544 public List<SingletonTagContext> singletonTag() { 8545 return getRuleContexts(SingletonTagContext.class); 8546 } 8547 public SingletonTagContext singletonTag(int i) { 8548 return getRuleContext(SingletonTagContext.class,i); 8549 } 8550 public List<ParagraphContext> paragraph() { 8551 return getRuleContexts(ParagraphContext.class); 8552 } 8553 public ParagraphContext paragraph(int i) { 8554 return getRuleContext(ParagraphContext.class,i); 8555 } 8556 public List<LiContext> li() { 8557 return getRuleContexts(LiContext.class); 8558 } 8559 public LiContext li(int i) { 8560 return getRuleContext(LiContext.class,i); 8561 } 8562 public List<TrContext> tr() { 8563 return getRuleContexts(TrContext.class); 8564 } 8565 public TrContext tr(int i) { 8566 return getRuleContext(TrContext.class,i); 8567 } 8568 public List<TdContext> td() { 8569 return getRuleContexts(TdContext.class); 8570 } 8571 public TdContext td(int i) { 8572 return getRuleContext(TdContext.class,i); 8573 } 8574 public List<ThContext> th() { 8575 return getRuleContexts(ThContext.class); 8576 } 8577 public ThContext th(int i) { 8578 return getRuleContext(ThContext.class,i); 8579 } 8580 public List<BodyContext> body() { 8581 return getRuleContexts(BodyContext.class); 8582 } 8583 public BodyContext body(int i) { 8584 return getRuleContext(BodyContext.class,i); 8585 } 8586 public List<ColgroupContext> colgroup() { 8587 return getRuleContexts(ColgroupContext.class); 8588 } 8589 public ColgroupContext colgroup(int i) { 8590 return getRuleContext(ColgroupContext.class,i); 8591 } 8592 public List<DdContext> dd() { 8593 return getRuleContexts(DdContext.class); 8594 } 8595 public DdContext dd(int i) { 8596 return getRuleContext(DdContext.class,i); 8597 } 8598 public List<DtContext> dt() { 8599 return getRuleContexts(DtContext.class); 8600 } 8601 public DtContext dt(int i) { 8602 return getRuleContext(DtContext.class,i); 8603 } 8604 public List<HeadContext> head() { 8605 return getRuleContexts(HeadContext.class); 8606 } 8607 public HeadContext head(int i) { 8608 return getRuleContext(HeadContext.class,i); 8609 } 8610 public List<OptionContext> option() { 8611 return getRuleContexts(OptionContext.class); 8612 } 8613 public OptionContext option(int i) { 8614 return getRuleContext(OptionContext.class,i); 8615 } 8616 public List<TbodyContext> tbody() { 8617 return getRuleContexts(TbodyContext.class); 8618 } 8619 public TbodyContext tbody(int i) { 8620 return getRuleContext(TbodyContext.class,i); 8621 } 8622 public List<TheadContext> thead() { 8623 return getRuleContexts(TheadContext.class); 8624 } 8625 public TheadContext thead(int i) { 8626 return getRuleContext(TheadContext.class,i); 8627 } 8628 public List<TfootContext> tfoot() { 8629 return getRuleContexts(TfootContext.class); 8630 } 8631 public TfootContext tfoot(int i) { 8632 return getRuleContext(TfootContext.class,i); 8633 } 8634 public List<PTagOpenContext> pTagOpen() { 8635 return getRuleContexts(PTagOpenContext.class); 8636 } 8637 public PTagOpenContext pTagOpen(int i) { 8638 return getRuleContext(PTagOpenContext.class,i); 8639 } 8640 public List<LiTagOpenContext> liTagOpen() { 8641 return getRuleContexts(LiTagOpenContext.class); 8642 } 8643 public LiTagOpenContext liTagOpen(int i) { 8644 return getRuleContext(LiTagOpenContext.class,i); 8645 } 8646 public List<TrTagOpenContext> trTagOpen() { 8647 return getRuleContexts(TrTagOpenContext.class); 8648 } 8649 public TrTagOpenContext trTagOpen(int i) { 8650 return getRuleContext(TrTagOpenContext.class,i); 8651 } 8652 public List<TdTagOpenContext> tdTagOpen() { 8653 return getRuleContexts(TdTagOpenContext.class); 8654 } 8655 public TdTagOpenContext tdTagOpen(int i) { 8656 return getRuleContext(TdTagOpenContext.class,i); 8657 } 8658 public List<ThTagOpenContext> thTagOpen() { 8659 return getRuleContexts(ThTagOpenContext.class); 8660 } 8661 public ThTagOpenContext thTagOpen(int i) { 8662 return getRuleContext(ThTagOpenContext.class,i); 8663 } 8664 public List<BodyTagOpenContext> bodyTagOpen() { 8665 return getRuleContexts(BodyTagOpenContext.class); 8666 } 8667 public BodyTagOpenContext bodyTagOpen(int i) { 8668 return getRuleContext(BodyTagOpenContext.class,i); 8669 } 8670 public List<ColgroupTagOpenContext> colgroupTagOpen() { 8671 return getRuleContexts(ColgroupTagOpenContext.class); 8672 } 8673 public ColgroupTagOpenContext colgroupTagOpen(int i) { 8674 return getRuleContext(ColgroupTagOpenContext.class,i); 8675 } 8676 public List<DdTagOpenContext> ddTagOpen() { 8677 return getRuleContexts(DdTagOpenContext.class); 8678 } 8679 public DdTagOpenContext ddTagOpen(int i) { 8680 return getRuleContext(DdTagOpenContext.class,i); 8681 } 8682 public List<DtTagOpenContext> dtTagOpen() { 8683 return getRuleContexts(DtTagOpenContext.class); 8684 } 8685 public DtTagOpenContext dtTagOpen(int i) { 8686 return getRuleContext(DtTagOpenContext.class,i); 8687 } 8688 public List<HeadTagOpenContext> headTagOpen() { 8689 return getRuleContexts(HeadTagOpenContext.class); 8690 } 8691 public HeadTagOpenContext headTagOpen(int i) { 8692 return getRuleContext(HeadTagOpenContext.class,i); 8693 } 8694 public List<OptionTagOpenContext> optionTagOpen() { 8695 return getRuleContexts(OptionTagOpenContext.class); 8696 } 8697 public OptionTagOpenContext optionTagOpen(int i) { 8698 return getRuleContext(OptionTagOpenContext.class,i); 8699 } 8700 public List<TbodyTagOpenContext> tbodyTagOpen() { 8701 return getRuleContexts(TbodyTagOpenContext.class); 8702 } 8703 public TbodyTagOpenContext tbodyTagOpen(int i) { 8704 return getRuleContext(TbodyTagOpenContext.class,i); 8705 } 8706 public List<TheadTagOpenContext> theadTagOpen() { 8707 return getRuleContexts(TheadTagOpenContext.class); 8708 } 8709 public TheadTagOpenContext theadTagOpen(int i) { 8710 return getRuleContext(TheadTagOpenContext.class,i); 8711 } 8712 public List<TfootTagOpenContext> tfootTagOpen() { 8713 return getRuleContexts(TfootTagOpenContext.class); 8714 } 8715 public TfootTagOpenContext tfootTagOpen(int i) { 8716 return getRuleContext(TfootTagOpenContext.class,i); 8717 } 8718 public List<HtmlCommentContext> htmlComment() { 8719 return getRuleContexts(HtmlCommentContext.class); 8720 } 8721 public HtmlCommentContext htmlComment(int i) { 8722 return getRuleContext(HtmlCommentContext.class,i); 8723 } 8724 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8725 public TerminalNode CDATA(int i) { 8726 return getToken(JavadocParser.CDATA, i); 8727 } 8728 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8729 public TerminalNode NEWLINE(int i) { 8730 return getToken(JavadocParser.NEWLINE, i); 8731 } 8732 public List<TextContext> text() { 8733 return getRuleContexts(TextContext.class); 8734 } 8735 public TextContext text(int i) { 8736 return getRuleContext(TextContext.class,i); 8737 } 8738 public List<JavadocInlineTagContext> javadocInlineTag() { 8739 return getRuleContexts(JavadocInlineTagContext.class); 8740 } 8741 public JavadocInlineTagContext javadocInlineTag(int i) { 8742 return getRuleContext(JavadocInlineTagContext.class,i); 8743 } 8744 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8745 public TerminalNode LEADING_ASTERISK(int i) { 8746 return getToken(JavadocParser.LEADING_ASTERISK, i); 8747 } 8748 public HtmlContext(ParserRuleContext parent, int invokingState) { 8749 super(parent, invokingState); 8750 } 8751 @Override public int getRuleIndex() { return RULE_html; } 8752 @Override 8753 public void enterRule(ParseTreeListener listener) { 8754 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtml(this); 8755 } 8756 @Override 8757 public void exitRule(ParseTreeListener listener) { 8758 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtml(this); 8759 } 8760 @Override 8761 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8762 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtml(this); 8763 else return visitor.visitChildren(this); 8764 } 8765 } 8766 8767 public final HtmlContext html() throws RecognitionException { 8768 HtmlContext _localctx = new HtmlContext(_ctx, getState()); 8769 enterRule(_localctx, 76, RULE_html); 8770 try { 8771 int _alt; 8772 enterOuterAlt(_localctx, 1); 8773 { 8774 setState(1020); 8775 htmlTagOpen(); 8776 setState(1060); 8777 _errHandler.sync(this); 8778 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 8779 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8780 if ( _alt==1 ) { 8781 { 8782 setState(1058); 8783 _errHandler.sync(this); 8784 switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { 8785 case 1: 8786 { 8787 setState(1021); 8788 htmlTag(); 8789 } 8790 break; 8791 case 2: 8792 { 8793 setState(1022); 8794 singletonTag(); 8795 } 8796 break; 8797 case 3: 8798 { 8799 setState(1023); 8800 paragraph(); 8801 } 8802 break; 8803 case 4: 8804 { 8805 setState(1024); 8806 li(); 8807 } 8808 break; 8809 case 5: 8810 { 8811 setState(1025); 8812 tr(); 8813 } 8814 break; 8815 case 6: 8816 { 8817 setState(1026); 8818 td(); 8819 } 8820 break; 8821 case 7: 8822 { 8823 setState(1027); 8824 th(); 8825 } 8826 break; 8827 case 8: 8828 { 8829 setState(1028); 8830 body(); 8831 } 8832 break; 8833 case 9: 8834 { 8835 setState(1029); 8836 colgroup(); 8837 } 8838 break; 8839 case 10: 8840 { 8841 setState(1030); 8842 dd(); 8843 } 8844 break; 8845 case 11: 8846 { 8847 setState(1031); 8848 dt(); 8849 } 8850 break; 8851 case 12: 8852 { 8853 setState(1032); 8854 head(); 8855 } 8856 break; 8857 case 13: 8858 { 8859 setState(1033); 8860 option(); 8861 } 8862 break; 8863 case 14: 8864 { 8865 setState(1034); 8866 tbody(); 8867 } 8868 break; 8869 case 15: 8870 { 8871 setState(1035); 8872 thead(); 8873 } 8874 break; 8875 case 16: 8876 { 8877 setState(1036); 8878 tfoot(); 8879 } 8880 break; 8881 case 17: 8882 { 8883 setState(1037); 8884 pTagOpen(); 8885 } 8886 break; 8887 case 18: 8888 { 8889 setState(1038); 8890 liTagOpen(); 8891 } 8892 break; 8893 case 19: 8894 { 8895 setState(1039); 8896 trTagOpen(); 8897 } 8898 break; 8899 case 20: 8900 { 8901 setState(1040); 8902 tdTagOpen(); 8903 } 8904 break; 8905 case 21: 8906 { 8907 setState(1041); 8908 thTagOpen(); 8909 } 8910 break; 8911 case 22: 8912 { 8913 setState(1042); 8914 bodyTagOpen(); 8915 } 8916 break; 8917 case 23: 8918 { 8919 setState(1043); 8920 colgroupTagOpen(); 8921 } 8922 break; 8923 case 24: 8924 { 8925 setState(1044); 8926 ddTagOpen(); 8927 } 8928 break; 8929 case 25: 8930 { 8931 setState(1045); 8932 dtTagOpen(); 8933 } 8934 break; 8935 case 26: 8936 { 8937 setState(1046); 8938 headTagOpen(); 8939 } 8940 break; 8941 case 27: 8942 { 8943 setState(1047); 8944 optionTagOpen(); 8945 } 8946 break; 8947 case 28: 8948 { 8949 setState(1048); 8950 tbodyTagOpen(); 8951 } 8952 break; 8953 case 29: 8954 { 8955 setState(1049); 8956 theadTagOpen(); 8957 } 8958 break; 8959 case 30: 8960 { 8961 setState(1050); 8962 tfootTagOpen(); 8963 } 8964 break; 8965 case 31: 8966 { 8967 { 8968 setState(1051); 8969 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8970 setState(1052); 8971 match(LEADING_ASTERISK); 8972 } 8973 } 8974 break; 8975 case 32: 8976 { 8977 setState(1053); 8978 htmlComment(); 8979 } 8980 break; 8981 case 33: 8982 { 8983 setState(1054); 8984 match(CDATA); 8985 } 8986 break; 8987 case 34: 8988 { 8989 setState(1055); 8990 match(NEWLINE); 8991 } 8992 break; 8993 case 35: 8994 { 8995 setState(1056); 8996 text(); 8997 } 8998 break; 8999 case 36: 9000 { 9001 setState(1057); 9002 javadocInlineTag(); 9003 } 9004 break; 9005 } 9006 } 9007 } 9008 setState(1062); 9009 _errHandler.sync(this); 9010 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 9011 } 9012 setState(1063); 9013 htmlTagClose(); 9014 } 9015 } 9016 catch (RecognitionException re) { 9017 _localctx.exception = re; 9018 _errHandler.reportError(this, re); 9019 _errHandler.recover(this, re); 9020 } 9021 finally { 9022 exitRule(); 9023 } 9024 return _localctx; 9025 } 9026 9027 public static class OptionTagOpenContext extends ParserRuleContext { 9028 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9029 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 9030 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9031 public List<AttributeContext> attribute() { 9032 return getRuleContexts(AttributeContext.class); 9033 } 9034 public AttributeContext attribute(int i) { 9035 return getRuleContext(AttributeContext.class,i); 9036 } 9037 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9038 public TerminalNode NEWLINE(int i) { 9039 return getToken(JavadocParser.NEWLINE, i); 9040 } 9041 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9042 public TerminalNode LEADING_ASTERISK(int i) { 9043 return getToken(JavadocParser.LEADING_ASTERISK, i); 9044 } 9045 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9046 public TerminalNode WS(int i) { 9047 return getToken(JavadocParser.WS, i); 9048 } 9049 public OptionTagOpenContext(ParserRuleContext parent, int invokingState) { 9050 super(parent, invokingState); 9051 } 9052 @Override public int getRuleIndex() { return RULE_optionTagOpen; } 9053 @Override 9054 public void enterRule(ParseTreeListener listener) { 9055 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagOpen(this); 9056 } 9057 @Override 9058 public void exitRule(ParseTreeListener listener) { 9059 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagOpen(this); 9060 } 9061 @Override 9062 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9063 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagOpen(this); 9064 else return visitor.visitChildren(this); 9065 } 9066 } 9067 9068 public final OptionTagOpenContext optionTagOpen() throws RecognitionException { 9069 OptionTagOpenContext _localctx = new OptionTagOpenContext(_ctx, getState()); 9070 enterRule(_localctx, 78, RULE_optionTagOpen); 9071 int _la; 9072 try { 9073 enterOuterAlt(_localctx, 1); 9074 { 9075 setState(1065); 9076 match(OPEN); 9077 setState(1066); 9078 match(OPTION_HTML_TAG_NAME); 9079 setState(1073); 9080 _errHandler.sync(this); 9081 _la = _input.LA(1); 9082 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9083 { 9084 setState(1071); 9085 _errHandler.sync(this); 9086 switch (_input.LA(1)) { 9087 case HTML_TAG_NAME: 9088 { 9089 setState(1067); 9090 attribute(); 9091 } 9092 break; 9093 case NEWLINE: 9094 { 9095 setState(1068); 9096 match(NEWLINE); 9097 } 9098 break; 9099 case LEADING_ASTERISK: 9100 { 9101 setState(1069); 9102 match(LEADING_ASTERISK); 9103 } 9104 break; 9105 case WS: 9106 { 9107 setState(1070); 9108 match(WS); 9109 } 9110 break; 9111 default: 9112 throw new NoViableAltException(this); 9113 } 9114 } 9115 setState(1075); 9116 _errHandler.sync(this); 9117 _la = _input.LA(1); 9118 } 9119 setState(1076); 9120 match(CLOSE); 9121 } 9122 } 9123 catch (RecognitionException re) { 9124 _localctx.exception = re; 9125 _errHandler.reportError(this, re); 9126 _errHandler.recover(this, re); 9127 } 9128 finally { 9129 exitRule(); 9130 } 9131 return _localctx; 9132 } 9133 9134 public static class OptionTagCloseContext extends ParserRuleContext { 9135 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9136 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9137 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 9138 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9139 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9140 public TerminalNode NEWLINE(int i) { 9141 return getToken(JavadocParser.NEWLINE, i); 9142 } 9143 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9144 public TerminalNode LEADING_ASTERISK(int i) { 9145 return getToken(JavadocParser.LEADING_ASTERISK, i); 9146 } 9147 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9148 public TerminalNode WS(int i) { 9149 return getToken(JavadocParser.WS, i); 9150 } 9151 public OptionTagCloseContext(ParserRuleContext parent, int invokingState) { 9152 super(parent, invokingState); 9153 } 9154 @Override public int getRuleIndex() { return RULE_optionTagClose; } 9155 @Override 9156 public void enterRule(ParseTreeListener listener) { 9157 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagClose(this); 9158 } 9159 @Override 9160 public void exitRule(ParseTreeListener listener) { 9161 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagClose(this); 9162 } 9163 @Override 9164 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9165 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagClose(this); 9166 else return visitor.visitChildren(this); 9167 } 9168 } 9169 9170 public final OptionTagCloseContext optionTagClose() throws RecognitionException { 9171 OptionTagCloseContext _localctx = new OptionTagCloseContext(_ctx, getState()); 9172 enterRule(_localctx, 80, RULE_optionTagClose); 9173 int _la; 9174 try { 9175 enterOuterAlt(_localctx, 1); 9176 { 9177 setState(1078); 9178 match(OPEN); 9179 setState(1079); 9180 match(SLASH); 9181 setState(1080); 9182 match(OPTION_HTML_TAG_NAME); 9183 setState(1084); 9184 _errHandler.sync(this); 9185 _la = _input.LA(1); 9186 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9187 { 9188 { 9189 setState(1081); 9190 _la = _input.LA(1); 9191 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9192 _errHandler.recoverInline(this); 9193 } 9194 else { 9195 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 9196 _errHandler.reportMatch(this); 9197 consume(); 9198 } 9199 } 9200 } 9201 setState(1086); 9202 _errHandler.sync(this); 9203 _la = _input.LA(1); 9204 } 9205 setState(1087); 9206 match(CLOSE); 9207 } 9208 } 9209 catch (RecognitionException re) { 9210 _localctx.exception = re; 9211 _errHandler.reportError(this, re); 9212 _errHandler.recover(this, re); 9213 } 9214 finally { 9215 exitRule(); 9216 } 9217 return _localctx; 9218 } 9219 9220 public static class OptionContext extends ParserRuleContext { 9221 public OptionTagOpenContext optionTagOpen() { 9222 return getRuleContext(OptionTagOpenContext.class,0); 9223 } 9224 public OptionTagCloseContext optionTagClose() { 9225 return getRuleContext(OptionTagCloseContext.class,0); 9226 } 9227 public List<HtmlTagContext> htmlTag() { 9228 return getRuleContexts(HtmlTagContext.class); 9229 } 9230 public HtmlTagContext htmlTag(int i) { 9231 return getRuleContext(HtmlTagContext.class,i); 9232 } 9233 public List<SingletonTagContext> singletonTag() { 9234 return getRuleContexts(SingletonTagContext.class); 9235 } 9236 public SingletonTagContext singletonTag(int i) { 9237 return getRuleContext(SingletonTagContext.class,i); 9238 } 9239 public List<ParagraphContext> paragraph() { 9240 return getRuleContexts(ParagraphContext.class); 9241 } 9242 public ParagraphContext paragraph(int i) { 9243 return getRuleContext(ParagraphContext.class,i); 9244 } 9245 public List<LiContext> li() { 9246 return getRuleContexts(LiContext.class); 9247 } 9248 public LiContext li(int i) { 9249 return getRuleContext(LiContext.class,i); 9250 } 9251 public List<TrContext> tr() { 9252 return getRuleContexts(TrContext.class); 9253 } 9254 public TrContext tr(int i) { 9255 return getRuleContext(TrContext.class,i); 9256 } 9257 public List<TdContext> td() { 9258 return getRuleContexts(TdContext.class); 9259 } 9260 public TdContext td(int i) { 9261 return getRuleContext(TdContext.class,i); 9262 } 9263 public List<ThContext> th() { 9264 return getRuleContexts(ThContext.class); 9265 } 9266 public ThContext th(int i) { 9267 return getRuleContext(ThContext.class,i); 9268 } 9269 public List<BodyContext> body() { 9270 return getRuleContexts(BodyContext.class); 9271 } 9272 public BodyContext body(int i) { 9273 return getRuleContext(BodyContext.class,i); 9274 } 9275 public List<ColgroupContext> colgroup() { 9276 return getRuleContexts(ColgroupContext.class); 9277 } 9278 public ColgroupContext colgroup(int i) { 9279 return getRuleContext(ColgroupContext.class,i); 9280 } 9281 public List<DdContext> dd() { 9282 return getRuleContexts(DdContext.class); 9283 } 9284 public DdContext dd(int i) { 9285 return getRuleContext(DdContext.class,i); 9286 } 9287 public List<DtContext> dt() { 9288 return getRuleContexts(DtContext.class); 9289 } 9290 public DtContext dt(int i) { 9291 return getRuleContext(DtContext.class,i); 9292 } 9293 public List<HeadContext> head() { 9294 return getRuleContexts(HeadContext.class); 9295 } 9296 public HeadContext head(int i) { 9297 return getRuleContext(HeadContext.class,i); 9298 } 9299 public List<HtmlContext> html() { 9300 return getRuleContexts(HtmlContext.class); 9301 } 9302 public HtmlContext html(int i) { 9303 return getRuleContext(HtmlContext.class,i); 9304 } 9305 public List<TbodyContext> tbody() { 9306 return getRuleContexts(TbodyContext.class); 9307 } 9308 public TbodyContext tbody(int i) { 9309 return getRuleContext(TbodyContext.class,i); 9310 } 9311 public List<TheadContext> thead() { 9312 return getRuleContexts(TheadContext.class); 9313 } 9314 public TheadContext thead(int i) { 9315 return getRuleContext(TheadContext.class,i); 9316 } 9317 public List<TfootContext> tfoot() { 9318 return getRuleContexts(TfootContext.class); 9319 } 9320 public TfootContext tfoot(int i) { 9321 return getRuleContext(TfootContext.class,i); 9322 } 9323 public List<PTagOpenContext> pTagOpen() { 9324 return getRuleContexts(PTagOpenContext.class); 9325 } 9326 public PTagOpenContext pTagOpen(int i) { 9327 return getRuleContext(PTagOpenContext.class,i); 9328 } 9329 public List<LiTagOpenContext> liTagOpen() { 9330 return getRuleContexts(LiTagOpenContext.class); 9331 } 9332 public LiTagOpenContext liTagOpen(int i) { 9333 return getRuleContext(LiTagOpenContext.class,i); 9334 } 9335 public List<TrTagOpenContext> trTagOpen() { 9336 return getRuleContexts(TrTagOpenContext.class); 9337 } 9338 public TrTagOpenContext trTagOpen(int i) { 9339 return getRuleContext(TrTagOpenContext.class,i); 9340 } 9341 public List<TdTagOpenContext> tdTagOpen() { 9342 return getRuleContexts(TdTagOpenContext.class); 9343 } 9344 public TdTagOpenContext tdTagOpen(int i) { 9345 return getRuleContext(TdTagOpenContext.class,i); 9346 } 9347 public List<ThTagOpenContext> thTagOpen() { 9348 return getRuleContexts(ThTagOpenContext.class); 9349 } 9350 public ThTagOpenContext thTagOpen(int i) { 9351 return getRuleContext(ThTagOpenContext.class,i); 9352 } 9353 public List<BodyTagOpenContext> bodyTagOpen() { 9354 return getRuleContexts(BodyTagOpenContext.class); 9355 } 9356 public BodyTagOpenContext bodyTagOpen(int i) { 9357 return getRuleContext(BodyTagOpenContext.class,i); 9358 } 9359 public List<ColgroupTagOpenContext> colgroupTagOpen() { 9360 return getRuleContexts(ColgroupTagOpenContext.class); 9361 } 9362 public ColgroupTagOpenContext colgroupTagOpen(int i) { 9363 return getRuleContext(ColgroupTagOpenContext.class,i); 9364 } 9365 public List<DdTagOpenContext> ddTagOpen() { 9366 return getRuleContexts(DdTagOpenContext.class); 9367 } 9368 public DdTagOpenContext ddTagOpen(int i) { 9369 return getRuleContext(DdTagOpenContext.class,i); 9370 } 9371 public List<DtTagOpenContext> dtTagOpen() { 9372 return getRuleContexts(DtTagOpenContext.class); 9373 } 9374 public DtTagOpenContext dtTagOpen(int i) { 9375 return getRuleContext(DtTagOpenContext.class,i); 9376 } 9377 public List<HeadTagOpenContext> headTagOpen() { 9378 return getRuleContexts(HeadTagOpenContext.class); 9379 } 9380 public HeadTagOpenContext headTagOpen(int i) { 9381 return getRuleContext(HeadTagOpenContext.class,i); 9382 } 9383 public List<HtmlTagOpenContext> htmlTagOpen() { 9384 return getRuleContexts(HtmlTagOpenContext.class); 9385 } 9386 public HtmlTagOpenContext htmlTagOpen(int i) { 9387 return getRuleContext(HtmlTagOpenContext.class,i); 9388 } 9389 public List<TbodyTagOpenContext> tbodyTagOpen() { 9390 return getRuleContexts(TbodyTagOpenContext.class); 9391 } 9392 public TbodyTagOpenContext tbodyTagOpen(int i) { 9393 return getRuleContext(TbodyTagOpenContext.class,i); 9394 } 9395 public List<TheadTagOpenContext> theadTagOpen() { 9396 return getRuleContexts(TheadTagOpenContext.class); 9397 } 9398 public TheadTagOpenContext theadTagOpen(int i) { 9399 return getRuleContext(TheadTagOpenContext.class,i); 9400 } 9401 public List<TfootTagOpenContext> tfootTagOpen() { 9402 return getRuleContexts(TfootTagOpenContext.class); 9403 } 9404 public TfootTagOpenContext tfootTagOpen(int i) { 9405 return getRuleContext(TfootTagOpenContext.class,i); 9406 } 9407 public List<HtmlCommentContext> htmlComment() { 9408 return getRuleContexts(HtmlCommentContext.class); 9409 } 9410 public HtmlCommentContext htmlComment(int i) { 9411 return getRuleContext(HtmlCommentContext.class,i); 9412 } 9413 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 9414 public TerminalNode CDATA(int i) { 9415 return getToken(JavadocParser.CDATA, i); 9416 } 9417 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9418 public TerminalNode NEWLINE(int i) { 9419 return getToken(JavadocParser.NEWLINE, i); 9420 } 9421 public List<TextContext> text() { 9422 return getRuleContexts(TextContext.class); 9423 } 9424 public TextContext text(int i) { 9425 return getRuleContext(TextContext.class,i); 9426 } 9427 public List<JavadocInlineTagContext> javadocInlineTag() { 9428 return getRuleContexts(JavadocInlineTagContext.class); 9429 } 9430 public JavadocInlineTagContext javadocInlineTag(int i) { 9431 return getRuleContext(JavadocInlineTagContext.class,i); 9432 } 9433 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9434 public TerminalNode LEADING_ASTERISK(int i) { 9435 return getToken(JavadocParser.LEADING_ASTERISK, i); 9436 } 9437 public OptionContext(ParserRuleContext parent, int invokingState) { 9438 super(parent, invokingState); 9439 } 9440 @Override public int getRuleIndex() { return RULE_option; } 9441 @Override 9442 public void enterRule(ParseTreeListener listener) { 9443 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOption(this); 9444 } 9445 @Override 9446 public void exitRule(ParseTreeListener listener) { 9447 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOption(this); 9448 } 9449 @Override 9450 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9451 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOption(this); 9452 else return visitor.visitChildren(this); 9453 } 9454 } 9455 9456 public final OptionContext option() throws RecognitionException { 9457 OptionContext _localctx = new OptionContext(_ctx, getState()); 9458 enterRule(_localctx, 82, RULE_option); 9459 try { 9460 int _alt; 9461 enterOuterAlt(_localctx, 1); 9462 { 9463 setState(1089); 9464 optionTagOpen(); 9465 setState(1129); 9466 _errHandler.sync(this); 9467 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 9468 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 9469 if ( _alt==1 ) { 9470 { 9471 setState(1127); 9472 _errHandler.sync(this); 9473 switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { 9474 case 1: 9475 { 9476 setState(1090); 9477 htmlTag(); 9478 } 9479 break; 9480 case 2: 9481 { 9482 setState(1091); 9483 singletonTag(); 9484 } 9485 break; 9486 case 3: 9487 { 9488 setState(1092); 9489 paragraph(); 9490 } 9491 break; 9492 case 4: 9493 { 9494 setState(1093); 9495 li(); 9496 } 9497 break; 9498 case 5: 9499 { 9500 setState(1094); 9501 tr(); 9502 } 9503 break; 9504 case 6: 9505 { 9506 setState(1095); 9507 td(); 9508 } 9509 break; 9510 case 7: 9511 { 9512 setState(1096); 9513 th(); 9514 } 9515 break; 9516 case 8: 9517 { 9518 setState(1097); 9519 body(); 9520 } 9521 break; 9522 case 9: 9523 { 9524 setState(1098); 9525 colgroup(); 9526 } 9527 break; 9528 case 10: 9529 { 9530 setState(1099); 9531 dd(); 9532 } 9533 break; 9534 case 11: 9535 { 9536 setState(1100); 9537 dt(); 9538 } 9539 break; 9540 case 12: 9541 { 9542 setState(1101); 9543 head(); 9544 } 9545 break; 9546 case 13: 9547 { 9548 setState(1102); 9549 html(); 9550 } 9551 break; 9552 case 14: 9553 { 9554 setState(1103); 9555 tbody(); 9556 } 9557 break; 9558 case 15: 9559 { 9560 setState(1104); 9561 thead(); 9562 } 9563 break; 9564 case 16: 9565 { 9566 setState(1105); 9567 tfoot(); 9568 } 9569 break; 9570 case 17: 9571 { 9572 setState(1106); 9573 pTagOpen(); 9574 } 9575 break; 9576 case 18: 9577 { 9578 setState(1107); 9579 liTagOpen(); 9580 } 9581 break; 9582 case 19: 9583 { 9584 setState(1108); 9585 trTagOpen(); 9586 } 9587 break; 9588 case 20: 9589 { 9590 setState(1109); 9591 tdTagOpen(); 9592 } 9593 break; 9594 case 21: 9595 { 9596 setState(1110); 9597 thTagOpen(); 9598 } 9599 break; 9600 case 22: 9601 { 9602 setState(1111); 9603 bodyTagOpen(); 9604 } 9605 break; 9606 case 23: 9607 { 9608 setState(1112); 9609 colgroupTagOpen(); 9610 } 9611 break; 9612 case 24: 9613 { 9614 setState(1113); 9615 ddTagOpen(); 9616 } 9617 break; 9618 case 25: 9619 { 9620 setState(1114); 9621 dtTagOpen(); 9622 } 9623 break; 9624 case 26: 9625 { 9626 setState(1115); 9627 headTagOpen(); 9628 } 9629 break; 9630 case 27: 9631 { 9632 setState(1116); 9633 htmlTagOpen(); 9634 } 9635 break; 9636 case 28: 9637 { 9638 setState(1117); 9639 tbodyTagOpen(); 9640 } 9641 break; 9642 case 29: 9643 { 9644 setState(1118); 9645 theadTagOpen(); 9646 } 9647 break; 9648 case 30: 9649 { 9650 setState(1119); 9651 tfootTagOpen(); 9652 } 9653 break; 9654 case 31: 9655 { 9656 { 9657 setState(1120); 9658 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 9659 setState(1121); 9660 match(LEADING_ASTERISK); 9661 } 9662 } 9663 break; 9664 case 32: 9665 { 9666 setState(1122); 9667 htmlComment(); 9668 } 9669 break; 9670 case 33: 9671 { 9672 setState(1123); 9673 match(CDATA); 9674 } 9675 break; 9676 case 34: 9677 { 9678 setState(1124); 9679 match(NEWLINE); 9680 } 9681 break; 9682 case 35: 9683 { 9684 setState(1125); 9685 text(); 9686 } 9687 break; 9688 case 36: 9689 { 9690 setState(1126); 9691 javadocInlineTag(); 9692 } 9693 break; 9694 } 9695 } 9696 } 9697 setState(1131); 9698 _errHandler.sync(this); 9699 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 9700 } 9701 setState(1132); 9702 optionTagClose(); 9703 } 9704 } 9705 catch (RecognitionException re) { 9706 _localctx.exception = re; 9707 _errHandler.reportError(this, re); 9708 _errHandler.recover(this, re); 9709 } 9710 finally { 9711 exitRule(); 9712 } 9713 return _localctx; 9714 } 9715 9716 public static class TbodyTagOpenContext extends ParserRuleContext { 9717 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9718 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9719 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9720 public List<AttributeContext> attribute() { 9721 return getRuleContexts(AttributeContext.class); 9722 } 9723 public AttributeContext attribute(int i) { 9724 return getRuleContext(AttributeContext.class,i); 9725 } 9726 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9727 public TerminalNode NEWLINE(int i) { 9728 return getToken(JavadocParser.NEWLINE, i); 9729 } 9730 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9731 public TerminalNode LEADING_ASTERISK(int i) { 9732 return getToken(JavadocParser.LEADING_ASTERISK, i); 9733 } 9734 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9735 public TerminalNode WS(int i) { 9736 return getToken(JavadocParser.WS, i); 9737 } 9738 public TbodyTagOpenContext(ParserRuleContext parent, int invokingState) { 9739 super(parent, invokingState); 9740 } 9741 @Override public int getRuleIndex() { return RULE_tbodyTagOpen; } 9742 @Override 9743 public void enterRule(ParseTreeListener listener) { 9744 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagOpen(this); 9745 } 9746 @Override 9747 public void exitRule(ParseTreeListener listener) { 9748 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagOpen(this); 9749 } 9750 @Override 9751 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9752 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagOpen(this); 9753 else return visitor.visitChildren(this); 9754 } 9755 } 9756 9757 public final TbodyTagOpenContext tbodyTagOpen() throws RecognitionException { 9758 TbodyTagOpenContext _localctx = new TbodyTagOpenContext(_ctx, getState()); 9759 enterRule(_localctx, 84, RULE_tbodyTagOpen); 9760 int _la; 9761 try { 9762 enterOuterAlt(_localctx, 1); 9763 { 9764 setState(1134); 9765 match(OPEN); 9766 setState(1135); 9767 match(TBODY_HTML_TAG_NAME); 9768 setState(1142); 9769 _errHandler.sync(this); 9770 _la = _input.LA(1); 9771 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9772 { 9773 setState(1140); 9774 _errHandler.sync(this); 9775 switch (_input.LA(1)) { 9776 case HTML_TAG_NAME: 9777 { 9778 setState(1136); 9779 attribute(); 9780 } 9781 break; 9782 case NEWLINE: 9783 { 9784 setState(1137); 9785 match(NEWLINE); 9786 } 9787 break; 9788 case LEADING_ASTERISK: 9789 { 9790 setState(1138); 9791 match(LEADING_ASTERISK); 9792 } 9793 break; 9794 case WS: 9795 { 9796 setState(1139); 9797 match(WS); 9798 } 9799 break; 9800 default: 9801 throw new NoViableAltException(this); 9802 } 9803 } 9804 setState(1144); 9805 _errHandler.sync(this); 9806 _la = _input.LA(1); 9807 } 9808 setState(1145); 9809 match(CLOSE); 9810 } 9811 } 9812 catch (RecognitionException re) { 9813 _localctx.exception = re; 9814 _errHandler.reportError(this, re); 9815 _errHandler.recover(this, re); 9816 } 9817 finally { 9818 exitRule(); 9819 } 9820 return _localctx; 9821 } 9822 9823 public static class TbodyTagCloseContext extends ParserRuleContext { 9824 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9825 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9826 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9827 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9828 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9829 public TerminalNode NEWLINE(int i) { 9830 return getToken(JavadocParser.NEWLINE, i); 9831 } 9832 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9833 public TerminalNode LEADING_ASTERISK(int i) { 9834 return getToken(JavadocParser.LEADING_ASTERISK, i); 9835 } 9836 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9837 public TerminalNode WS(int i) { 9838 return getToken(JavadocParser.WS, i); 9839 } 9840 public TbodyTagCloseContext(ParserRuleContext parent, int invokingState) { 9841 super(parent, invokingState); 9842 } 9843 @Override public int getRuleIndex() { return RULE_tbodyTagClose; } 9844 @Override 9845 public void enterRule(ParseTreeListener listener) { 9846 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagClose(this); 9847 } 9848 @Override 9849 public void exitRule(ParseTreeListener listener) { 9850 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagClose(this); 9851 } 9852 @Override 9853 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9854 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagClose(this); 9855 else return visitor.visitChildren(this); 9856 } 9857 } 9858 9859 public final TbodyTagCloseContext tbodyTagClose() throws RecognitionException { 9860 TbodyTagCloseContext _localctx = new TbodyTagCloseContext(_ctx, getState()); 9861 enterRule(_localctx, 86, RULE_tbodyTagClose); 9862 int _la; 9863 try { 9864 enterOuterAlt(_localctx, 1); 9865 { 9866 setState(1147); 9867 match(OPEN); 9868 setState(1148); 9869 match(SLASH); 9870 setState(1149); 9871 match(TBODY_HTML_TAG_NAME); 9872 setState(1153); 9873 _errHandler.sync(this); 9874 _la = _input.LA(1); 9875 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9876 { 9877 { 9878 setState(1150); 9879 _la = _input.LA(1); 9880 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9881 _errHandler.recoverInline(this); 9882 } 9883 else { 9884 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 9885 _errHandler.reportMatch(this); 9886 consume(); 9887 } 9888 } 9889 } 9890 setState(1155); 9891 _errHandler.sync(this); 9892 _la = _input.LA(1); 9893 } 9894 setState(1156); 9895 match(CLOSE); 9896 } 9897 } 9898 catch (RecognitionException re) { 9899 _localctx.exception = re; 9900 _errHandler.reportError(this, re); 9901 _errHandler.recover(this, re); 9902 } 9903 finally { 9904 exitRule(); 9905 } 9906 return _localctx; 9907 } 9908 9909 public static class TbodyContext extends ParserRuleContext { 9910 public TbodyTagOpenContext tbodyTagOpen() { 9911 return getRuleContext(TbodyTagOpenContext.class,0); 9912 } 9913 public TbodyTagCloseContext tbodyTagClose() { 9914 return getRuleContext(TbodyTagCloseContext.class,0); 9915 } 9916 public List<HtmlTagContext> htmlTag() { 9917 return getRuleContexts(HtmlTagContext.class); 9918 } 9919 public HtmlTagContext htmlTag(int i) { 9920 return getRuleContext(HtmlTagContext.class,i); 9921 } 9922 public List<SingletonTagContext> singletonTag() { 9923 return getRuleContexts(SingletonTagContext.class); 9924 } 9925 public SingletonTagContext singletonTag(int i) { 9926 return getRuleContext(SingletonTagContext.class,i); 9927 } 9928 public List<ParagraphContext> paragraph() { 9929 return getRuleContexts(ParagraphContext.class); 9930 } 9931 public ParagraphContext paragraph(int i) { 9932 return getRuleContext(ParagraphContext.class,i); 9933 } 9934 public List<LiContext> li() { 9935 return getRuleContexts(LiContext.class); 9936 } 9937 public LiContext li(int i) { 9938 return getRuleContext(LiContext.class,i); 9939 } 9940 public List<TrContext> tr() { 9941 return getRuleContexts(TrContext.class); 9942 } 9943 public TrContext tr(int i) { 9944 return getRuleContext(TrContext.class,i); 9945 } 9946 public List<TdContext> td() { 9947 return getRuleContexts(TdContext.class); 9948 } 9949 public TdContext td(int i) { 9950 return getRuleContext(TdContext.class,i); 9951 } 9952 public List<ThContext> th() { 9953 return getRuleContexts(ThContext.class); 9954 } 9955 public ThContext th(int i) { 9956 return getRuleContext(ThContext.class,i); 9957 } 9958 public List<BodyContext> body() { 9959 return getRuleContexts(BodyContext.class); 9960 } 9961 public BodyContext body(int i) { 9962 return getRuleContext(BodyContext.class,i); 9963 } 9964 public List<ColgroupContext> colgroup() { 9965 return getRuleContexts(ColgroupContext.class); 9966 } 9967 public ColgroupContext colgroup(int i) { 9968 return getRuleContext(ColgroupContext.class,i); 9969 } 9970 public List<DdContext> dd() { 9971 return getRuleContexts(DdContext.class); 9972 } 9973 public DdContext dd(int i) { 9974 return getRuleContext(DdContext.class,i); 9975 } 9976 public List<DtContext> dt() { 9977 return getRuleContexts(DtContext.class); 9978 } 9979 public DtContext dt(int i) { 9980 return getRuleContext(DtContext.class,i); 9981 } 9982 public List<HeadContext> head() { 9983 return getRuleContexts(HeadContext.class); 9984 } 9985 public HeadContext head(int i) { 9986 return getRuleContext(HeadContext.class,i); 9987 } 9988 public List<HtmlContext> html() { 9989 return getRuleContexts(HtmlContext.class); 9990 } 9991 public HtmlContext html(int i) { 9992 return getRuleContext(HtmlContext.class,i); 9993 } 9994 public List<OptionContext> option() { 9995 return getRuleContexts(OptionContext.class); 9996 } 9997 public OptionContext option(int i) { 9998 return getRuleContext(OptionContext.class,i); 9999 } 10000 public List<TheadContext> thead() { 10001 return getRuleContexts(TheadContext.class); 10002 } 10003 public TheadContext thead(int i) { 10004 return getRuleContext(TheadContext.class,i); 10005 } 10006 public List<TfootContext> tfoot() { 10007 return getRuleContexts(TfootContext.class); 10008 } 10009 public TfootContext tfoot(int i) { 10010 return getRuleContext(TfootContext.class,i); 10011 } 10012 public List<PTagOpenContext> pTagOpen() { 10013 return getRuleContexts(PTagOpenContext.class); 10014 } 10015 public PTagOpenContext pTagOpen(int i) { 10016 return getRuleContext(PTagOpenContext.class,i); 10017 } 10018 public List<LiTagOpenContext> liTagOpen() { 10019 return getRuleContexts(LiTagOpenContext.class); 10020 } 10021 public LiTagOpenContext liTagOpen(int i) { 10022 return getRuleContext(LiTagOpenContext.class,i); 10023 } 10024 public List<TrTagOpenContext> trTagOpen() { 10025 return getRuleContexts(TrTagOpenContext.class); 10026 } 10027 public TrTagOpenContext trTagOpen(int i) { 10028 return getRuleContext(TrTagOpenContext.class,i); 10029 } 10030 public List<TdTagOpenContext> tdTagOpen() { 10031 return getRuleContexts(TdTagOpenContext.class); 10032 } 10033 public TdTagOpenContext tdTagOpen(int i) { 10034 return getRuleContext(TdTagOpenContext.class,i); 10035 } 10036 public List<ThTagOpenContext> thTagOpen() { 10037 return getRuleContexts(ThTagOpenContext.class); 10038 } 10039 public ThTagOpenContext thTagOpen(int i) { 10040 return getRuleContext(ThTagOpenContext.class,i); 10041 } 10042 public List<BodyTagOpenContext> bodyTagOpen() { 10043 return getRuleContexts(BodyTagOpenContext.class); 10044 } 10045 public BodyTagOpenContext bodyTagOpen(int i) { 10046 return getRuleContext(BodyTagOpenContext.class,i); 10047 } 10048 public List<ColgroupTagOpenContext> colgroupTagOpen() { 10049 return getRuleContexts(ColgroupTagOpenContext.class); 10050 } 10051 public ColgroupTagOpenContext colgroupTagOpen(int i) { 10052 return getRuleContext(ColgroupTagOpenContext.class,i); 10053 } 10054 public List<DdTagOpenContext> ddTagOpen() { 10055 return getRuleContexts(DdTagOpenContext.class); 10056 } 10057 public DdTagOpenContext ddTagOpen(int i) { 10058 return getRuleContext(DdTagOpenContext.class,i); 10059 } 10060 public List<DtTagOpenContext> dtTagOpen() { 10061 return getRuleContexts(DtTagOpenContext.class); 10062 } 10063 public DtTagOpenContext dtTagOpen(int i) { 10064 return getRuleContext(DtTagOpenContext.class,i); 10065 } 10066 public List<HeadTagOpenContext> headTagOpen() { 10067 return getRuleContexts(HeadTagOpenContext.class); 10068 } 10069 public HeadTagOpenContext headTagOpen(int i) { 10070 return getRuleContext(HeadTagOpenContext.class,i); 10071 } 10072 public List<HtmlTagOpenContext> htmlTagOpen() { 10073 return getRuleContexts(HtmlTagOpenContext.class); 10074 } 10075 public HtmlTagOpenContext htmlTagOpen(int i) { 10076 return getRuleContext(HtmlTagOpenContext.class,i); 10077 } 10078 public List<OptionTagOpenContext> optionTagOpen() { 10079 return getRuleContexts(OptionTagOpenContext.class); 10080 } 10081 public OptionTagOpenContext optionTagOpen(int i) { 10082 return getRuleContext(OptionTagOpenContext.class,i); 10083 } 10084 public List<TheadTagOpenContext> theadTagOpen() { 10085 return getRuleContexts(TheadTagOpenContext.class); 10086 } 10087 public TheadTagOpenContext theadTagOpen(int i) { 10088 return getRuleContext(TheadTagOpenContext.class,i); 10089 } 10090 public List<TfootTagOpenContext> tfootTagOpen() { 10091 return getRuleContexts(TfootTagOpenContext.class); 10092 } 10093 public TfootTagOpenContext tfootTagOpen(int i) { 10094 return getRuleContext(TfootTagOpenContext.class,i); 10095 } 10096 public List<HtmlCommentContext> htmlComment() { 10097 return getRuleContexts(HtmlCommentContext.class); 10098 } 10099 public HtmlCommentContext htmlComment(int i) { 10100 return getRuleContext(HtmlCommentContext.class,i); 10101 } 10102 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10103 public TerminalNode CDATA(int i) { 10104 return getToken(JavadocParser.CDATA, i); 10105 } 10106 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10107 public TerminalNode NEWLINE(int i) { 10108 return getToken(JavadocParser.NEWLINE, i); 10109 } 10110 public List<TextContext> text() { 10111 return getRuleContexts(TextContext.class); 10112 } 10113 public TextContext text(int i) { 10114 return getRuleContext(TextContext.class,i); 10115 } 10116 public List<JavadocInlineTagContext> javadocInlineTag() { 10117 return getRuleContexts(JavadocInlineTagContext.class); 10118 } 10119 public JavadocInlineTagContext javadocInlineTag(int i) { 10120 return getRuleContext(JavadocInlineTagContext.class,i); 10121 } 10122 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10123 public TerminalNode LEADING_ASTERISK(int i) { 10124 return getToken(JavadocParser.LEADING_ASTERISK, i); 10125 } 10126 public TbodyContext(ParserRuleContext parent, int invokingState) { 10127 super(parent, invokingState); 10128 } 10129 @Override public int getRuleIndex() { return RULE_tbody; } 10130 @Override 10131 public void enterRule(ParseTreeListener listener) { 10132 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbody(this); 10133 } 10134 @Override 10135 public void exitRule(ParseTreeListener listener) { 10136 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbody(this); 10137 } 10138 @Override 10139 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10140 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbody(this); 10141 else return visitor.visitChildren(this); 10142 } 10143 } 10144 10145 public final TbodyContext tbody() throws RecognitionException { 10146 TbodyContext _localctx = new TbodyContext(_ctx, getState()); 10147 enterRule(_localctx, 88, RULE_tbody); 10148 try { 10149 int _alt; 10150 enterOuterAlt(_localctx, 1); 10151 { 10152 setState(1158); 10153 tbodyTagOpen(); 10154 setState(1198); 10155 _errHandler.sync(this); 10156 _alt = getInterpreter().adaptivePredict(_input,81,_ctx); 10157 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10158 if ( _alt==1 ) { 10159 { 10160 setState(1196); 10161 _errHandler.sync(this); 10162 switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) { 10163 case 1: 10164 { 10165 setState(1159); 10166 htmlTag(); 10167 } 10168 break; 10169 case 2: 10170 { 10171 setState(1160); 10172 singletonTag(); 10173 } 10174 break; 10175 case 3: 10176 { 10177 setState(1161); 10178 paragraph(); 10179 } 10180 break; 10181 case 4: 10182 { 10183 setState(1162); 10184 li(); 10185 } 10186 break; 10187 case 5: 10188 { 10189 setState(1163); 10190 tr(); 10191 } 10192 break; 10193 case 6: 10194 { 10195 setState(1164); 10196 td(); 10197 } 10198 break; 10199 case 7: 10200 { 10201 setState(1165); 10202 th(); 10203 } 10204 break; 10205 case 8: 10206 { 10207 setState(1166); 10208 body(); 10209 } 10210 break; 10211 case 9: 10212 { 10213 setState(1167); 10214 colgroup(); 10215 } 10216 break; 10217 case 10: 10218 { 10219 setState(1168); 10220 dd(); 10221 } 10222 break; 10223 case 11: 10224 { 10225 setState(1169); 10226 dt(); 10227 } 10228 break; 10229 case 12: 10230 { 10231 setState(1170); 10232 head(); 10233 } 10234 break; 10235 case 13: 10236 { 10237 setState(1171); 10238 html(); 10239 } 10240 break; 10241 case 14: 10242 { 10243 setState(1172); 10244 option(); 10245 } 10246 break; 10247 case 15: 10248 { 10249 setState(1173); 10250 thead(); 10251 } 10252 break; 10253 case 16: 10254 { 10255 setState(1174); 10256 tfoot(); 10257 } 10258 break; 10259 case 17: 10260 { 10261 setState(1175); 10262 pTagOpen(); 10263 } 10264 break; 10265 case 18: 10266 { 10267 setState(1176); 10268 liTagOpen(); 10269 } 10270 break; 10271 case 19: 10272 { 10273 setState(1177); 10274 trTagOpen(); 10275 } 10276 break; 10277 case 20: 10278 { 10279 setState(1178); 10280 tdTagOpen(); 10281 } 10282 break; 10283 case 21: 10284 { 10285 setState(1179); 10286 thTagOpen(); 10287 } 10288 break; 10289 case 22: 10290 { 10291 setState(1180); 10292 bodyTagOpen(); 10293 } 10294 break; 10295 case 23: 10296 { 10297 setState(1181); 10298 colgroupTagOpen(); 10299 } 10300 break; 10301 case 24: 10302 { 10303 setState(1182); 10304 ddTagOpen(); 10305 } 10306 break; 10307 case 25: 10308 { 10309 setState(1183); 10310 dtTagOpen(); 10311 } 10312 break; 10313 case 26: 10314 { 10315 setState(1184); 10316 headTagOpen(); 10317 } 10318 break; 10319 case 27: 10320 { 10321 setState(1185); 10322 htmlTagOpen(); 10323 } 10324 break; 10325 case 28: 10326 { 10327 setState(1186); 10328 optionTagOpen(); 10329 } 10330 break; 10331 case 29: 10332 { 10333 setState(1187); 10334 theadTagOpen(); 10335 } 10336 break; 10337 case 30: 10338 { 10339 setState(1188); 10340 tfootTagOpen(); 10341 } 10342 break; 10343 case 31: 10344 { 10345 { 10346 setState(1189); 10347 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10348 setState(1190); 10349 match(LEADING_ASTERISK); 10350 } 10351 } 10352 break; 10353 case 32: 10354 { 10355 setState(1191); 10356 htmlComment(); 10357 } 10358 break; 10359 case 33: 10360 { 10361 setState(1192); 10362 match(CDATA); 10363 } 10364 break; 10365 case 34: 10366 { 10367 setState(1193); 10368 match(NEWLINE); 10369 } 10370 break; 10371 case 35: 10372 { 10373 setState(1194); 10374 text(); 10375 } 10376 break; 10377 case 36: 10378 { 10379 setState(1195); 10380 javadocInlineTag(); 10381 } 10382 break; 10383 } 10384 } 10385 } 10386 setState(1200); 10387 _errHandler.sync(this); 10388 _alt = getInterpreter().adaptivePredict(_input,81,_ctx); 10389 } 10390 setState(1201); 10391 tbodyTagClose(); 10392 } 10393 } 10394 catch (RecognitionException re) { 10395 _localctx.exception = re; 10396 _errHandler.reportError(this, re); 10397 _errHandler.recover(this, re); 10398 } 10399 finally { 10400 exitRule(); 10401 } 10402 return _localctx; 10403 } 10404 10405 public static class TfootTagOpenContext extends ParserRuleContext { 10406 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10407 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 10408 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10409 public List<AttributeContext> attribute() { 10410 return getRuleContexts(AttributeContext.class); 10411 } 10412 public AttributeContext attribute(int i) { 10413 return getRuleContext(AttributeContext.class,i); 10414 } 10415 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10416 public TerminalNode NEWLINE(int i) { 10417 return getToken(JavadocParser.NEWLINE, i); 10418 } 10419 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10420 public TerminalNode LEADING_ASTERISK(int i) { 10421 return getToken(JavadocParser.LEADING_ASTERISK, i); 10422 } 10423 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10424 public TerminalNode WS(int i) { 10425 return getToken(JavadocParser.WS, i); 10426 } 10427 public TfootTagOpenContext(ParserRuleContext parent, int invokingState) { 10428 super(parent, invokingState); 10429 } 10430 @Override public int getRuleIndex() { return RULE_tfootTagOpen; } 10431 @Override 10432 public void enterRule(ParseTreeListener listener) { 10433 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagOpen(this); 10434 } 10435 @Override 10436 public void exitRule(ParseTreeListener listener) { 10437 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagOpen(this); 10438 } 10439 @Override 10440 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10441 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagOpen(this); 10442 else return visitor.visitChildren(this); 10443 } 10444 } 10445 10446 public final TfootTagOpenContext tfootTagOpen() throws RecognitionException { 10447 TfootTagOpenContext _localctx = new TfootTagOpenContext(_ctx, getState()); 10448 enterRule(_localctx, 90, RULE_tfootTagOpen); 10449 int _la; 10450 try { 10451 enterOuterAlt(_localctx, 1); 10452 { 10453 setState(1203); 10454 match(OPEN); 10455 setState(1204); 10456 match(TFOOT_HTML_TAG_NAME); 10457 setState(1211); 10458 _errHandler.sync(this); 10459 _la = _input.LA(1); 10460 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 10461 { 10462 setState(1209); 10463 _errHandler.sync(this); 10464 switch (_input.LA(1)) { 10465 case HTML_TAG_NAME: 10466 { 10467 setState(1205); 10468 attribute(); 10469 } 10470 break; 10471 case NEWLINE: 10472 { 10473 setState(1206); 10474 match(NEWLINE); 10475 } 10476 break; 10477 case LEADING_ASTERISK: 10478 { 10479 setState(1207); 10480 match(LEADING_ASTERISK); 10481 } 10482 break; 10483 case WS: 10484 { 10485 setState(1208); 10486 match(WS); 10487 } 10488 break; 10489 default: 10490 throw new NoViableAltException(this); 10491 } 10492 } 10493 setState(1213); 10494 _errHandler.sync(this); 10495 _la = _input.LA(1); 10496 } 10497 setState(1214); 10498 match(CLOSE); 10499 } 10500 } 10501 catch (RecognitionException re) { 10502 _localctx.exception = re; 10503 _errHandler.reportError(this, re); 10504 _errHandler.recover(this, re); 10505 } 10506 finally { 10507 exitRule(); 10508 } 10509 return _localctx; 10510 } 10511 10512 public static class TfootTagCloseContext extends ParserRuleContext { 10513 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10514 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 10515 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 10516 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10517 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10518 public TerminalNode NEWLINE(int i) { 10519 return getToken(JavadocParser.NEWLINE, i); 10520 } 10521 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10522 public TerminalNode LEADING_ASTERISK(int i) { 10523 return getToken(JavadocParser.LEADING_ASTERISK, i); 10524 } 10525 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10526 public TerminalNode WS(int i) { 10527 return getToken(JavadocParser.WS, i); 10528 } 10529 public TfootTagCloseContext(ParserRuleContext parent, int invokingState) { 10530 super(parent, invokingState); 10531 } 10532 @Override public int getRuleIndex() { return RULE_tfootTagClose; } 10533 @Override 10534 public void enterRule(ParseTreeListener listener) { 10535 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagClose(this); 10536 } 10537 @Override 10538 public void exitRule(ParseTreeListener listener) { 10539 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagClose(this); 10540 } 10541 @Override 10542 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10543 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagClose(this); 10544 else return visitor.visitChildren(this); 10545 } 10546 } 10547 10548 public final TfootTagCloseContext tfootTagClose() throws RecognitionException { 10549 TfootTagCloseContext _localctx = new TfootTagCloseContext(_ctx, getState()); 10550 enterRule(_localctx, 92, RULE_tfootTagClose); 10551 int _la; 10552 try { 10553 enterOuterAlt(_localctx, 1); 10554 { 10555 setState(1216); 10556 match(OPEN); 10557 setState(1217); 10558 match(SLASH); 10559 setState(1218); 10560 match(TFOOT_HTML_TAG_NAME); 10561 setState(1222); 10562 _errHandler.sync(this); 10563 _la = _input.LA(1); 10564 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10565 { 10566 { 10567 setState(1219); 10568 _la = _input.LA(1); 10569 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10570 _errHandler.recoverInline(this); 10571 } 10572 else { 10573 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 10574 _errHandler.reportMatch(this); 10575 consume(); 10576 } 10577 } 10578 } 10579 setState(1224); 10580 _errHandler.sync(this); 10581 _la = _input.LA(1); 10582 } 10583 setState(1225); 10584 match(CLOSE); 10585 } 10586 } 10587 catch (RecognitionException re) { 10588 _localctx.exception = re; 10589 _errHandler.reportError(this, re); 10590 _errHandler.recover(this, re); 10591 } 10592 finally { 10593 exitRule(); 10594 } 10595 return _localctx; 10596 } 10597 10598 public static class TfootContext extends ParserRuleContext { 10599 public TfootTagOpenContext tfootTagOpen() { 10600 return getRuleContext(TfootTagOpenContext.class,0); 10601 } 10602 public TfootTagCloseContext tfootTagClose() { 10603 return getRuleContext(TfootTagCloseContext.class,0); 10604 } 10605 public List<HtmlTagContext> htmlTag() { 10606 return getRuleContexts(HtmlTagContext.class); 10607 } 10608 public HtmlTagContext htmlTag(int i) { 10609 return getRuleContext(HtmlTagContext.class,i); 10610 } 10611 public List<SingletonTagContext> singletonTag() { 10612 return getRuleContexts(SingletonTagContext.class); 10613 } 10614 public SingletonTagContext singletonTag(int i) { 10615 return getRuleContext(SingletonTagContext.class,i); 10616 } 10617 public List<ParagraphContext> paragraph() { 10618 return getRuleContexts(ParagraphContext.class); 10619 } 10620 public ParagraphContext paragraph(int i) { 10621 return getRuleContext(ParagraphContext.class,i); 10622 } 10623 public List<LiContext> li() { 10624 return getRuleContexts(LiContext.class); 10625 } 10626 public LiContext li(int i) { 10627 return getRuleContext(LiContext.class,i); 10628 } 10629 public List<TrContext> tr() { 10630 return getRuleContexts(TrContext.class); 10631 } 10632 public TrContext tr(int i) { 10633 return getRuleContext(TrContext.class,i); 10634 } 10635 public List<TdContext> td() { 10636 return getRuleContexts(TdContext.class); 10637 } 10638 public TdContext td(int i) { 10639 return getRuleContext(TdContext.class,i); 10640 } 10641 public List<ThContext> th() { 10642 return getRuleContexts(ThContext.class); 10643 } 10644 public ThContext th(int i) { 10645 return getRuleContext(ThContext.class,i); 10646 } 10647 public List<BodyContext> body() { 10648 return getRuleContexts(BodyContext.class); 10649 } 10650 public BodyContext body(int i) { 10651 return getRuleContext(BodyContext.class,i); 10652 } 10653 public List<ColgroupContext> colgroup() { 10654 return getRuleContexts(ColgroupContext.class); 10655 } 10656 public ColgroupContext colgroup(int i) { 10657 return getRuleContext(ColgroupContext.class,i); 10658 } 10659 public List<DdContext> dd() { 10660 return getRuleContexts(DdContext.class); 10661 } 10662 public DdContext dd(int i) { 10663 return getRuleContext(DdContext.class,i); 10664 } 10665 public List<DtContext> dt() { 10666 return getRuleContexts(DtContext.class); 10667 } 10668 public DtContext dt(int i) { 10669 return getRuleContext(DtContext.class,i); 10670 } 10671 public List<HeadContext> head() { 10672 return getRuleContexts(HeadContext.class); 10673 } 10674 public HeadContext head(int i) { 10675 return getRuleContext(HeadContext.class,i); 10676 } 10677 public List<HtmlContext> html() { 10678 return getRuleContexts(HtmlContext.class); 10679 } 10680 public HtmlContext html(int i) { 10681 return getRuleContext(HtmlContext.class,i); 10682 } 10683 public List<OptionContext> option() { 10684 return getRuleContexts(OptionContext.class); 10685 } 10686 public OptionContext option(int i) { 10687 return getRuleContext(OptionContext.class,i); 10688 } 10689 public List<TbodyContext> tbody() { 10690 return getRuleContexts(TbodyContext.class); 10691 } 10692 public TbodyContext tbody(int i) { 10693 return getRuleContext(TbodyContext.class,i); 10694 } 10695 public List<TheadContext> thead() { 10696 return getRuleContexts(TheadContext.class); 10697 } 10698 public TheadContext thead(int i) { 10699 return getRuleContext(TheadContext.class,i); 10700 } 10701 public List<PTagOpenContext> pTagOpen() { 10702 return getRuleContexts(PTagOpenContext.class); 10703 } 10704 public PTagOpenContext pTagOpen(int i) { 10705 return getRuleContext(PTagOpenContext.class,i); 10706 } 10707 public List<LiTagOpenContext> liTagOpen() { 10708 return getRuleContexts(LiTagOpenContext.class); 10709 } 10710 public LiTagOpenContext liTagOpen(int i) { 10711 return getRuleContext(LiTagOpenContext.class,i); 10712 } 10713 public List<TrTagOpenContext> trTagOpen() { 10714 return getRuleContexts(TrTagOpenContext.class); 10715 } 10716 public TrTagOpenContext trTagOpen(int i) { 10717 return getRuleContext(TrTagOpenContext.class,i); 10718 } 10719 public List<TdTagOpenContext> tdTagOpen() { 10720 return getRuleContexts(TdTagOpenContext.class); 10721 } 10722 public TdTagOpenContext tdTagOpen(int i) { 10723 return getRuleContext(TdTagOpenContext.class,i); 10724 } 10725 public List<ThTagOpenContext> thTagOpen() { 10726 return getRuleContexts(ThTagOpenContext.class); 10727 } 10728 public ThTagOpenContext thTagOpen(int i) { 10729 return getRuleContext(ThTagOpenContext.class,i); 10730 } 10731 public List<BodyTagOpenContext> bodyTagOpen() { 10732 return getRuleContexts(BodyTagOpenContext.class); 10733 } 10734 public BodyTagOpenContext bodyTagOpen(int i) { 10735 return getRuleContext(BodyTagOpenContext.class,i); 10736 } 10737 public List<ColgroupTagOpenContext> colgroupTagOpen() { 10738 return getRuleContexts(ColgroupTagOpenContext.class); 10739 } 10740 public ColgroupTagOpenContext colgroupTagOpen(int i) { 10741 return getRuleContext(ColgroupTagOpenContext.class,i); 10742 } 10743 public List<DdTagOpenContext> ddTagOpen() { 10744 return getRuleContexts(DdTagOpenContext.class); 10745 } 10746 public DdTagOpenContext ddTagOpen(int i) { 10747 return getRuleContext(DdTagOpenContext.class,i); 10748 } 10749 public List<DtTagOpenContext> dtTagOpen() { 10750 return getRuleContexts(DtTagOpenContext.class); 10751 } 10752 public DtTagOpenContext dtTagOpen(int i) { 10753 return getRuleContext(DtTagOpenContext.class,i); 10754 } 10755 public List<HeadTagOpenContext> headTagOpen() { 10756 return getRuleContexts(HeadTagOpenContext.class); 10757 } 10758 public HeadTagOpenContext headTagOpen(int i) { 10759 return getRuleContext(HeadTagOpenContext.class,i); 10760 } 10761 public List<HtmlTagOpenContext> htmlTagOpen() { 10762 return getRuleContexts(HtmlTagOpenContext.class); 10763 } 10764 public HtmlTagOpenContext htmlTagOpen(int i) { 10765 return getRuleContext(HtmlTagOpenContext.class,i); 10766 } 10767 public List<OptionTagOpenContext> optionTagOpen() { 10768 return getRuleContexts(OptionTagOpenContext.class); 10769 } 10770 public OptionTagOpenContext optionTagOpen(int i) { 10771 return getRuleContext(OptionTagOpenContext.class,i); 10772 } 10773 public List<TbodyTagOpenContext> tbodyTagOpen() { 10774 return getRuleContexts(TbodyTagOpenContext.class); 10775 } 10776 public TbodyTagOpenContext tbodyTagOpen(int i) { 10777 return getRuleContext(TbodyTagOpenContext.class,i); 10778 } 10779 public List<TheadTagOpenContext> theadTagOpen() { 10780 return getRuleContexts(TheadTagOpenContext.class); 10781 } 10782 public TheadTagOpenContext theadTagOpen(int i) { 10783 return getRuleContext(TheadTagOpenContext.class,i); 10784 } 10785 public List<HtmlCommentContext> htmlComment() { 10786 return getRuleContexts(HtmlCommentContext.class); 10787 } 10788 public HtmlCommentContext htmlComment(int i) { 10789 return getRuleContext(HtmlCommentContext.class,i); 10790 } 10791 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10792 public TerminalNode CDATA(int i) { 10793 return getToken(JavadocParser.CDATA, i); 10794 } 10795 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10796 public TerminalNode NEWLINE(int i) { 10797 return getToken(JavadocParser.NEWLINE, i); 10798 } 10799 public List<TextContext> text() { 10800 return getRuleContexts(TextContext.class); 10801 } 10802 public TextContext text(int i) { 10803 return getRuleContext(TextContext.class,i); 10804 } 10805 public List<JavadocInlineTagContext> javadocInlineTag() { 10806 return getRuleContexts(JavadocInlineTagContext.class); 10807 } 10808 public JavadocInlineTagContext javadocInlineTag(int i) { 10809 return getRuleContext(JavadocInlineTagContext.class,i); 10810 } 10811 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10812 public TerminalNode LEADING_ASTERISK(int i) { 10813 return getToken(JavadocParser.LEADING_ASTERISK, i); 10814 } 10815 public TfootContext(ParserRuleContext parent, int invokingState) { 10816 super(parent, invokingState); 10817 } 10818 @Override public int getRuleIndex() { return RULE_tfoot; } 10819 @Override 10820 public void enterRule(ParseTreeListener listener) { 10821 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfoot(this); 10822 } 10823 @Override 10824 public void exitRule(ParseTreeListener listener) { 10825 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfoot(this); 10826 } 10827 @Override 10828 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10829 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfoot(this); 10830 else return visitor.visitChildren(this); 10831 } 10832 } 10833 10834 public final TfootContext tfoot() throws RecognitionException { 10835 TfootContext _localctx = new TfootContext(_ctx, getState()); 10836 enterRule(_localctx, 94, RULE_tfoot); 10837 try { 10838 int _alt; 10839 enterOuterAlt(_localctx, 1); 10840 { 10841 setState(1227); 10842 tfootTagOpen(); 10843 setState(1267); 10844 _errHandler.sync(this); 10845 _alt = getInterpreter().adaptivePredict(_input,86,_ctx); 10846 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10847 if ( _alt==1 ) { 10848 { 10849 setState(1265); 10850 _errHandler.sync(this); 10851 switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) { 10852 case 1: 10853 { 10854 setState(1228); 10855 htmlTag(); 10856 } 10857 break; 10858 case 2: 10859 { 10860 setState(1229); 10861 singletonTag(); 10862 } 10863 break; 10864 case 3: 10865 { 10866 setState(1230); 10867 paragraph(); 10868 } 10869 break; 10870 case 4: 10871 { 10872 setState(1231); 10873 li(); 10874 } 10875 break; 10876 case 5: 10877 { 10878 setState(1232); 10879 tr(); 10880 } 10881 break; 10882 case 6: 10883 { 10884 setState(1233); 10885 td(); 10886 } 10887 break; 10888 case 7: 10889 { 10890 setState(1234); 10891 th(); 10892 } 10893 break; 10894 case 8: 10895 { 10896 setState(1235); 10897 body(); 10898 } 10899 break; 10900 case 9: 10901 { 10902 setState(1236); 10903 colgroup(); 10904 } 10905 break; 10906 case 10: 10907 { 10908 setState(1237); 10909 dd(); 10910 } 10911 break; 10912 case 11: 10913 { 10914 setState(1238); 10915 dt(); 10916 } 10917 break; 10918 case 12: 10919 { 10920 setState(1239); 10921 head(); 10922 } 10923 break; 10924 case 13: 10925 { 10926 setState(1240); 10927 html(); 10928 } 10929 break; 10930 case 14: 10931 { 10932 setState(1241); 10933 option(); 10934 } 10935 break; 10936 case 15: 10937 { 10938 setState(1242); 10939 tbody(); 10940 } 10941 break; 10942 case 16: 10943 { 10944 setState(1243); 10945 thead(); 10946 } 10947 break; 10948 case 17: 10949 { 10950 setState(1244); 10951 pTagOpen(); 10952 } 10953 break; 10954 case 18: 10955 { 10956 setState(1245); 10957 liTagOpen(); 10958 } 10959 break; 10960 case 19: 10961 { 10962 setState(1246); 10963 trTagOpen(); 10964 } 10965 break; 10966 case 20: 10967 { 10968 setState(1247); 10969 tdTagOpen(); 10970 } 10971 break; 10972 case 21: 10973 { 10974 setState(1248); 10975 thTagOpen(); 10976 } 10977 break; 10978 case 22: 10979 { 10980 setState(1249); 10981 bodyTagOpen(); 10982 } 10983 break; 10984 case 23: 10985 { 10986 setState(1250); 10987 colgroupTagOpen(); 10988 } 10989 break; 10990 case 24: 10991 { 10992 setState(1251); 10993 ddTagOpen(); 10994 } 10995 break; 10996 case 25: 10997 { 10998 setState(1252); 10999 dtTagOpen(); 11000 } 11001 break; 11002 case 26: 11003 { 11004 setState(1253); 11005 headTagOpen(); 11006 } 11007 break; 11008 case 27: 11009 { 11010 setState(1254); 11011 htmlTagOpen(); 11012 } 11013 break; 11014 case 28: 11015 { 11016 setState(1255); 11017 optionTagOpen(); 11018 } 11019 break; 11020 case 29: 11021 { 11022 setState(1256); 11023 tbodyTagOpen(); 11024 } 11025 break; 11026 case 30: 11027 { 11028 setState(1257); 11029 theadTagOpen(); 11030 } 11031 break; 11032 case 31: 11033 { 11034 { 11035 setState(1258); 11036 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 11037 setState(1259); 11038 match(LEADING_ASTERISK); 11039 } 11040 } 11041 break; 11042 case 32: 11043 { 11044 setState(1260); 11045 htmlComment(); 11046 } 11047 break; 11048 case 33: 11049 { 11050 setState(1261); 11051 match(CDATA); 11052 } 11053 break; 11054 case 34: 11055 { 11056 setState(1262); 11057 match(NEWLINE); 11058 } 11059 break; 11060 case 35: 11061 { 11062 setState(1263); 11063 text(); 11064 } 11065 break; 11066 case 36: 11067 { 11068 setState(1264); 11069 javadocInlineTag(); 11070 } 11071 break; 11072 } 11073 } 11074 } 11075 setState(1269); 11076 _errHandler.sync(this); 11077 _alt = getInterpreter().adaptivePredict(_input,86,_ctx); 11078 } 11079 setState(1270); 11080 tfootTagClose(); 11081 } 11082 } 11083 catch (RecognitionException re) { 11084 _localctx.exception = re; 11085 _errHandler.reportError(this, re); 11086 _errHandler.recover(this, re); 11087 } 11088 finally { 11089 exitRule(); 11090 } 11091 return _localctx; 11092 } 11093 11094 public static class TheadTagOpenContext extends ParserRuleContext { 11095 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11096 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11097 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11098 public List<AttributeContext> attribute() { 11099 return getRuleContexts(AttributeContext.class); 11100 } 11101 public AttributeContext attribute(int i) { 11102 return getRuleContext(AttributeContext.class,i); 11103 } 11104 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11105 public TerminalNode NEWLINE(int i) { 11106 return getToken(JavadocParser.NEWLINE, i); 11107 } 11108 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11109 public TerminalNode LEADING_ASTERISK(int i) { 11110 return getToken(JavadocParser.LEADING_ASTERISK, i); 11111 } 11112 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11113 public TerminalNode WS(int i) { 11114 return getToken(JavadocParser.WS, i); 11115 } 11116 public TheadTagOpenContext(ParserRuleContext parent, int invokingState) { 11117 super(parent, invokingState); 11118 } 11119 @Override public int getRuleIndex() { return RULE_theadTagOpen; } 11120 @Override 11121 public void enterRule(ParseTreeListener listener) { 11122 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagOpen(this); 11123 } 11124 @Override 11125 public void exitRule(ParseTreeListener listener) { 11126 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagOpen(this); 11127 } 11128 @Override 11129 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11130 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagOpen(this); 11131 else return visitor.visitChildren(this); 11132 } 11133 } 11134 11135 public final TheadTagOpenContext theadTagOpen() throws RecognitionException { 11136 TheadTagOpenContext _localctx = new TheadTagOpenContext(_ctx, getState()); 11137 enterRule(_localctx, 96, RULE_theadTagOpen); 11138 int _la; 11139 try { 11140 enterOuterAlt(_localctx, 1); 11141 { 11142 setState(1272); 11143 match(OPEN); 11144 setState(1273); 11145 match(THEAD_HTML_TAG_NAME); 11146 setState(1280); 11147 _errHandler.sync(this); 11148 _la = _input.LA(1); 11149 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11150 { 11151 setState(1278); 11152 _errHandler.sync(this); 11153 switch (_input.LA(1)) { 11154 case HTML_TAG_NAME: 11155 { 11156 setState(1274); 11157 attribute(); 11158 } 11159 break; 11160 case NEWLINE: 11161 { 11162 setState(1275); 11163 match(NEWLINE); 11164 } 11165 break; 11166 case LEADING_ASTERISK: 11167 { 11168 setState(1276); 11169 match(LEADING_ASTERISK); 11170 } 11171 break; 11172 case WS: 11173 { 11174 setState(1277); 11175 match(WS); 11176 } 11177 break; 11178 default: 11179 throw new NoViableAltException(this); 11180 } 11181 } 11182 setState(1282); 11183 _errHandler.sync(this); 11184 _la = _input.LA(1); 11185 } 11186 setState(1283); 11187 match(CLOSE); 11188 } 11189 } 11190 catch (RecognitionException re) { 11191 _localctx.exception = re; 11192 _errHandler.reportError(this, re); 11193 _errHandler.recover(this, re); 11194 } 11195 finally { 11196 exitRule(); 11197 } 11198 return _localctx; 11199 } 11200 11201 public static class TheadTagCloseContext extends ParserRuleContext { 11202 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11203 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 11204 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11205 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11206 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11207 public TerminalNode NEWLINE(int i) { 11208 return getToken(JavadocParser.NEWLINE, i); 11209 } 11210 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11211 public TerminalNode LEADING_ASTERISK(int i) { 11212 return getToken(JavadocParser.LEADING_ASTERISK, i); 11213 } 11214 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11215 public TerminalNode WS(int i) { 11216 return getToken(JavadocParser.WS, i); 11217 } 11218 public TheadTagCloseContext(ParserRuleContext parent, int invokingState) { 11219 super(parent, invokingState); 11220 } 11221 @Override public int getRuleIndex() { return RULE_theadTagClose; } 11222 @Override 11223 public void enterRule(ParseTreeListener listener) { 11224 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagClose(this); 11225 } 11226 @Override 11227 public void exitRule(ParseTreeListener listener) { 11228 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagClose(this); 11229 } 11230 @Override 11231 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11232 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagClose(this); 11233 else return visitor.visitChildren(this); 11234 } 11235 } 11236 11237 public final TheadTagCloseContext theadTagClose() throws RecognitionException { 11238 TheadTagCloseContext _localctx = new TheadTagCloseContext(_ctx, getState()); 11239 enterRule(_localctx, 98, RULE_theadTagClose); 11240 int _la; 11241 try { 11242 enterOuterAlt(_localctx, 1); 11243 { 11244 setState(1285); 11245 match(OPEN); 11246 setState(1286); 11247 match(SLASH); 11248 setState(1287); 11249 match(THEAD_HTML_TAG_NAME); 11250 setState(1291); 11251 _errHandler.sync(this); 11252 _la = _input.LA(1); 11253 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 11254 { 11255 { 11256 setState(1288); 11257 _la = _input.LA(1); 11258 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 11259 _errHandler.recoverInline(this); 11260 } 11261 else { 11262 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 11263 _errHandler.reportMatch(this); 11264 consume(); 11265 } 11266 } 11267 } 11268 setState(1293); 11269 _errHandler.sync(this); 11270 _la = _input.LA(1); 11271 } 11272 setState(1294); 11273 match(CLOSE); 11274 } 11275 } 11276 catch (RecognitionException re) { 11277 _localctx.exception = re; 11278 _errHandler.reportError(this, re); 11279 _errHandler.recover(this, re); 11280 } 11281 finally { 11282 exitRule(); 11283 } 11284 return _localctx; 11285 } 11286 11287 public static class TheadContext extends ParserRuleContext { 11288 public TheadTagOpenContext theadTagOpen() { 11289 return getRuleContext(TheadTagOpenContext.class,0); 11290 } 11291 public TheadTagCloseContext theadTagClose() { 11292 return getRuleContext(TheadTagCloseContext.class,0); 11293 } 11294 public List<HtmlTagContext> htmlTag() { 11295 return getRuleContexts(HtmlTagContext.class); 11296 } 11297 public HtmlTagContext htmlTag(int i) { 11298 return getRuleContext(HtmlTagContext.class,i); 11299 } 11300 public List<SingletonTagContext> singletonTag() { 11301 return getRuleContexts(SingletonTagContext.class); 11302 } 11303 public SingletonTagContext singletonTag(int i) { 11304 return getRuleContext(SingletonTagContext.class,i); 11305 } 11306 public List<ParagraphContext> paragraph() { 11307 return getRuleContexts(ParagraphContext.class); 11308 } 11309 public ParagraphContext paragraph(int i) { 11310 return getRuleContext(ParagraphContext.class,i); 11311 } 11312 public List<LiContext> li() { 11313 return getRuleContexts(LiContext.class); 11314 } 11315 public LiContext li(int i) { 11316 return getRuleContext(LiContext.class,i); 11317 } 11318 public List<TrContext> tr() { 11319 return getRuleContexts(TrContext.class); 11320 } 11321 public TrContext tr(int i) { 11322 return getRuleContext(TrContext.class,i); 11323 } 11324 public List<TdContext> td() { 11325 return getRuleContexts(TdContext.class); 11326 } 11327 public TdContext td(int i) { 11328 return getRuleContext(TdContext.class,i); 11329 } 11330 public List<ThContext> th() { 11331 return getRuleContexts(ThContext.class); 11332 } 11333 public ThContext th(int i) { 11334 return getRuleContext(ThContext.class,i); 11335 } 11336 public List<BodyContext> body() { 11337 return getRuleContexts(BodyContext.class); 11338 } 11339 public BodyContext body(int i) { 11340 return getRuleContext(BodyContext.class,i); 11341 } 11342 public List<ColgroupContext> colgroup() { 11343 return getRuleContexts(ColgroupContext.class); 11344 } 11345 public ColgroupContext colgroup(int i) { 11346 return getRuleContext(ColgroupContext.class,i); 11347 } 11348 public List<DdContext> dd() { 11349 return getRuleContexts(DdContext.class); 11350 } 11351 public DdContext dd(int i) { 11352 return getRuleContext(DdContext.class,i); 11353 } 11354 public List<DtContext> dt() { 11355 return getRuleContexts(DtContext.class); 11356 } 11357 public DtContext dt(int i) { 11358 return getRuleContext(DtContext.class,i); 11359 } 11360 public List<HeadContext> head() { 11361 return getRuleContexts(HeadContext.class); 11362 } 11363 public HeadContext head(int i) { 11364 return getRuleContext(HeadContext.class,i); 11365 } 11366 public List<HtmlContext> html() { 11367 return getRuleContexts(HtmlContext.class); 11368 } 11369 public HtmlContext html(int i) { 11370 return getRuleContext(HtmlContext.class,i); 11371 } 11372 public List<OptionContext> option() { 11373 return getRuleContexts(OptionContext.class); 11374 } 11375 public OptionContext option(int i) { 11376 return getRuleContext(OptionContext.class,i); 11377 } 11378 public List<TbodyContext> tbody() { 11379 return getRuleContexts(TbodyContext.class); 11380 } 11381 public TbodyContext tbody(int i) { 11382 return getRuleContext(TbodyContext.class,i); 11383 } 11384 public List<TfootContext> tfoot() { 11385 return getRuleContexts(TfootContext.class); 11386 } 11387 public TfootContext tfoot(int i) { 11388 return getRuleContext(TfootContext.class,i); 11389 } 11390 public List<PTagOpenContext> pTagOpen() { 11391 return getRuleContexts(PTagOpenContext.class); 11392 } 11393 public PTagOpenContext pTagOpen(int i) { 11394 return getRuleContext(PTagOpenContext.class,i); 11395 } 11396 public List<LiTagOpenContext> liTagOpen() { 11397 return getRuleContexts(LiTagOpenContext.class); 11398 } 11399 public LiTagOpenContext liTagOpen(int i) { 11400 return getRuleContext(LiTagOpenContext.class,i); 11401 } 11402 public List<TrTagOpenContext> trTagOpen() { 11403 return getRuleContexts(TrTagOpenContext.class); 11404 } 11405 public TrTagOpenContext trTagOpen(int i) { 11406 return getRuleContext(TrTagOpenContext.class,i); 11407 } 11408 public List<TdTagOpenContext> tdTagOpen() { 11409 return getRuleContexts(TdTagOpenContext.class); 11410 } 11411 public TdTagOpenContext tdTagOpen(int i) { 11412 return getRuleContext(TdTagOpenContext.class,i); 11413 } 11414 public List<ThTagOpenContext> thTagOpen() { 11415 return getRuleContexts(ThTagOpenContext.class); 11416 } 11417 public ThTagOpenContext thTagOpen(int i) { 11418 return getRuleContext(ThTagOpenContext.class,i); 11419 } 11420 public List<BodyTagOpenContext> bodyTagOpen() { 11421 return getRuleContexts(BodyTagOpenContext.class); 11422 } 11423 public BodyTagOpenContext bodyTagOpen(int i) { 11424 return getRuleContext(BodyTagOpenContext.class,i); 11425 } 11426 public List<ColgroupTagOpenContext> colgroupTagOpen() { 11427 return getRuleContexts(ColgroupTagOpenContext.class); 11428 } 11429 public ColgroupTagOpenContext colgroupTagOpen(int i) { 11430 return getRuleContext(ColgroupTagOpenContext.class,i); 11431 } 11432 public List<DdTagOpenContext> ddTagOpen() { 11433 return getRuleContexts(DdTagOpenContext.class); 11434 } 11435 public DdTagOpenContext ddTagOpen(int i) { 11436 return getRuleContext(DdTagOpenContext.class,i); 11437 } 11438 public List<DtTagOpenContext> dtTagOpen() { 11439 return getRuleContexts(DtTagOpenContext.class); 11440 } 11441 public DtTagOpenContext dtTagOpen(int i) { 11442 return getRuleContext(DtTagOpenContext.class,i); 11443 } 11444 public List<HeadTagOpenContext> headTagOpen() { 11445 return getRuleContexts(HeadTagOpenContext.class); 11446 } 11447 public HeadTagOpenContext headTagOpen(int i) { 11448 return getRuleContext(HeadTagOpenContext.class,i); 11449 } 11450 public List<HtmlTagOpenContext> htmlTagOpen() { 11451 return getRuleContexts(HtmlTagOpenContext.class); 11452 } 11453 public HtmlTagOpenContext htmlTagOpen(int i) { 11454 return getRuleContext(HtmlTagOpenContext.class,i); 11455 } 11456 public List<OptionTagOpenContext> optionTagOpen() { 11457 return getRuleContexts(OptionTagOpenContext.class); 11458 } 11459 public OptionTagOpenContext optionTagOpen(int i) { 11460 return getRuleContext(OptionTagOpenContext.class,i); 11461 } 11462 public List<TbodyTagOpenContext> tbodyTagOpen() { 11463 return getRuleContexts(TbodyTagOpenContext.class); 11464 } 11465 public TbodyTagOpenContext tbodyTagOpen(int i) { 11466 return getRuleContext(TbodyTagOpenContext.class,i); 11467 } 11468 public List<TfootTagOpenContext> tfootTagOpen() { 11469 return getRuleContexts(TfootTagOpenContext.class); 11470 } 11471 public TfootTagOpenContext tfootTagOpen(int i) { 11472 return getRuleContext(TfootTagOpenContext.class,i); 11473 } 11474 public List<HtmlCommentContext> htmlComment() { 11475 return getRuleContexts(HtmlCommentContext.class); 11476 } 11477 public HtmlCommentContext htmlComment(int i) { 11478 return getRuleContext(HtmlCommentContext.class,i); 11479 } 11480 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 11481 public TerminalNode CDATA(int i) { 11482 return getToken(JavadocParser.CDATA, i); 11483 } 11484 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11485 public TerminalNode NEWLINE(int i) { 11486 return getToken(JavadocParser.NEWLINE, i); 11487 } 11488 public List<TextContext> text() { 11489 return getRuleContexts(TextContext.class); 11490 } 11491 public TextContext text(int i) { 11492 return getRuleContext(TextContext.class,i); 11493 } 11494 public List<JavadocInlineTagContext> javadocInlineTag() { 11495 return getRuleContexts(JavadocInlineTagContext.class); 11496 } 11497 public JavadocInlineTagContext javadocInlineTag(int i) { 11498 return getRuleContext(JavadocInlineTagContext.class,i); 11499 } 11500 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11501 public TerminalNode LEADING_ASTERISK(int i) { 11502 return getToken(JavadocParser.LEADING_ASTERISK, i); 11503 } 11504 public TheadContext(ParserRuleContext parent, int invokingState) { 11505 super(parent, invokingState); 11506 } 11507 @Override public int getRuleIndex() { return RULE_thead; } 11508 @Override 11509 public void enterRule(ParseTreeListener listener) { 11510 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThead(this); 11511 } 11512 @Override 11513 public void exitRule(ParseTreeListener listener) { 11514 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThead(this); 11515 } 11516 @Override 11517 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11518 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThead(this); 11519 else return visitor.visitChildren(this); 11520 } 11521 } 11522 11523 public final TheadContext thead() throws RecognitionException { 11524 TheadContext _localctx = new TheadContext(_ctx, getState()); 11525 enterRule(_localctx, 100, RULE_thead); 11526 try { 11527 int _alt; 11528 enterOuterAlt(_localctx, 1); 11529 { 11530 setState(1296); 11531 theadTagOpen(); 11532 setState(1336); 11533 _errHandler.sync(this); 11534 _alt = getInterpreter().adaptivePredict(_input,91,_ctx); 11535 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 11536 if ( _alt==1 ) { 11537 { 11538 setState(1334); 11539 _errHandler.sync(this); 11540 switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) { 11541 case 1: 11542 { 11543 setState(1297); 11544 htmlTag(); 11545 } 11546 break; 11547 case 2: 11548 { 11549 setState(1298); 11550 singletonTag(); 11551 } 11552 break; 11553 case 3: 11554 { 11555 setState(1299); 11556 paragraph(); 11557 } 11558 break; 11559 case 4: 11560 { 11561 setState(1300); 11562 li(); 11563 } 11564 break; 11565 case 5: 11566 { 11567 setState(1301); 11568 tr(); 11569 } 11570 break; 11571 case 6: 11572 { 11573 setState(1302); 11574 td(); 11575 } 11576 break; 11577 case 7: 11578 { 11579 setState(1303); 11580 th(); 11581 } 11582 break; 11583 case 8: 11584 { 11585 setState(1304); 11586 body(); 11587 } 11588 break; 11589 case 9: 11590 { 11591 setState(1305); 11592 colgroup(); 11593 } 11594 break; 11595 case 10: 11596 { 11597 setState(1306); 11598 dd(); 11599 } 11600 break; 11601 case 11: 11602 { 11603 setState(1307); 11604 dt(); 11605 } 11606 break; 11607 case 12: 11608 { 11609 setState(1308); 11610 head(); 11611 } 11612 break; 11613 case 13: 11614 { 11615 setState(1309); 11616 html(); 11617 } 11618 break; 11619 case 14: 11620 { 11621 setState(1310); 11622 option(); 11623 } 11624 break; 11625 case 15: 11626 { 11627 setState(1311); 11628 tbody(); 11629 } 11630 break; 11631 case 16: 11632 { 11633 setState(1312); 11634 tfoot(); 11635 } 11636 break; 11637 case 17: 11638 { 11639 setState(1313); 11640 pTagOpen(); 11641 } 11642 break; 11643 case 18: 11644 { 11645 setState(1314); 11646 liTagOpen(); 11647 } 11648 break; 11649 case 19: 11650 { 11651 setState(1315); 11652 trTagOpen(); 11653 } 11654 break; 11655 case 20: 11656 { 11657 setState(1316); 11658 tdTagOpen(); 11659 } 11660 break; 11661 case 21: 11662 { 11663 setState(1317); 11664 thTagOpen(); 11665 } 11666 break; 11667 case 22: 11668 { 11669 setState(1318); 11670 bodyTagOpen(); 11671 } 11672 break; 11673 case 23: 11674 { 11675 setState(1319); 11676 colgroupTagOpen(); 11677 } 11678 break; 11679 case 24: 11680 { 11681 setState(1320); 11682 ddTagOpen(); 11683 } 11684 break; 11685 case 25: 11686 { 11687 setState(1321); 11688 dtTagOpen(); 11689 } 11690 break; 11691 case 26: 11692 { 11693 setState(1322); 11694 headTagOpen(); 11695 } 11696 break; 11697 case 27: 11698 { 11699 setState(1323); 11700 htmlTagOpen(); 11701 } 11702 break; 11703 case 28: 11704 { 11705 setState(1324); 11706 optionTagOpen(); 11707 } 11708 break; 11709 case 29: 11710 { 11711 setState(1325); 11712 tbodyTagOpen(); 11713 } 11714 break; 11715 case 30: 11716 { 11717 setState(1326); 11718 tfootTagOpen(); 11719 } 11720 break; 11721 case 31: 11722 { 11723 { 11724 setState(1327); 11725 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 11726 setState(1328); 11727 match(LEADING_ASTERISK); 11728 } 11729 } 11730 break; 11731 case 32: 11732 { 11733 setState(1329); 11734 htmlComment(); 11735 } 11736 break; 11737 case 33: 11738 { 11739 setState(1330); 11740 match(CDATA); 11741 } 11742 break; 11743 case 34: 11744 { 11745 setState(1331); 11746 match(NEWLINE); 11747 } 11748 break; 11749 case 35: 11750 { 11751 setState(1332); 11752 text(); 11753 } 11754 break; 11755 case 36: 11756 { 11757 setState(1333); 11758 javadocInlineTag(); 11759 } 11760 break; 11761 } 11762 } 11763 } 11764 setState(1338); 11765 _errHandler.sync(this); 11766 _alt = getInterpreter().adaptivePredict(_input,91,_ctx); 11767 } 11768 setState(1339); 11769 theadTagClose(); 11770 } 11771 } 11772 catch (RecognitionException re) { 11773 _localctx.exception = re; 11774 _errHandler.reportError(this, re); 11775 _errHandler.recover(this, re); 11776 } 11777 finally { 11778 exitRule(); 11779 } 11780 return _localctx; 11781 } 11782 11783 public static class SingletonElementContext extends ParserRuleContext { 11784 public SingletonTagContext singletonTag() { 11785 return getRuleContext(SingletonTagContext.class,0); 11786 } 11787 public AreaTagContext areaTag() { 11788 return getRuleContext(AreaTagContext.class,0); 11789 } 11790 public BaseTagContext baseTag() { 11791 return getRuleContext(BaseTagContext.class,0); 11792 } 11793 public BasefontTagContext basefontTag() { 11794 return getRuleContext(BasefontTagContext.class,0); 11795 } 11796 public BrTagContext brTag() { 11797 return getRuleContext(BrTagContext.class,0); 11798 } 11799 public ColTagContext colTag() { 11800 return getRuleContext(ColTagContext.class,0); 11801 } 11802 public FrameTagContext frameTag() { 11803 return getRuleContext(FrameTagContext.class,0); 11804 } 11805 public HrTagContext hrTag() { 11806 return getRuleContext(HrTagContext.class,0); 11807 } 11808 public ImgTagContext imgTag() { 11809 return getRuleContext(ImgTagContext.class,0); 11810 } 11811 public InputTagContext inputTag() { 11812 return getRuleContext(InputTagContext.class,0); 11813 } 11814 public IsindexTagContext isindexTag() { 11815 return getRuleContext(IsindexTagContext.class,0); 11816 } 11817 public LinkTagContext linkTag() { 11818 return getRuleContext(LinkTagContext.class,0); 11819 } 11820 public MetaTagContext metaTag() { 11821 return getRuleContext(MetaTagContext.class,0); 11822 } 11823 public ParamTagContext paramTag() { 11824 return getRuleContext(ParamTagContext.class,0); 11825 } 11826 public WrongSinletonTagContext wrongSinletonTag() { 11827 return getRuleContext(WrongSinletonTagContext.class,0); 11828 } 11829 public SingletonElementContext(ParserRuleContext parent, int invokingState) { 11830 super(parent, invokingState); 11831 } 11832 @Override public int getRuleIndex() { return RULE_singletonElement; } 11833 @Override 11834 public void enterRule(ParseTreeListener listener) { 11835 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonElement(this); 11836 } 11837 @Override 11838 public void exitRule(ParseTreeListener listener) { 11839 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonElement(this); 11840 } 11841 @Override 11842 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11843 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonElement(this); 11844 else return visitor.visitChildren(this); 11845 } 11846 } 11847 11848 public final SingletonElementContext singletonElement() throws RecognitionException { 11849 SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState()); 11850 enterRule(_localctx, 102, RULE_singletonElement); 11851 try { 11852 setState(1356); 11853 _errHandler.sync(this); 11854 switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) { 11855 case 1: 11856 enterOuterAlt(_localctx, 1); 11857 { 11858 setState(1341); 11859 singletonTag(); 11860 } 11861 break; 11862 case 2: 11863 enterOuterAlt(_localctx, 2); 11864 { 11865 setState(1342); 11866 areaTag(); 11867 } 11868 break; 11869 case 3: 11870 enterOuterAlt(_localctx, 3); 11871 { 11872 setState(1343); 11873 baseTag(); 11874 } 11875 break; 11876 case 4: 11877 enterOuterAlt(_localctx, 4); 11878 { 11879 setState(1344); 11880 basefontTag(); 11881 } 11882 break; 11883 case 5: 11884 enterOuterAlt(_localctx, 5); 11885 { 11886 setState(1345); 11887 brTag(); 11888 } 11889 break; 11890 case 6: 11891 enterOuterAlt(_localctx, 6); 11892 { 11893 setState(1346); 11894 colTag(); 11895 } 11896 break; 11897 case 7: 11898 enterOuterAlt(_localctx, 7); 11899 { 11900 setState(1347); 11901 frameTag(); 11902 } 11903 break; 11904 case 8: 11905 enterOuterAlt(_localctx, 8); 11906 { 11907 setState(1348); 11908 hrTag(); 11909 } 11910 break; 11911 case 9: 11912 enterOuterAlt(_localctx, 9); 11913 { 11914 setState(1349); 11915 imgTag(); 11916 } 11917 break; 11918 case 10: 11919 enterOuterAlt(_localctx, 10); 11920 { 11921 setState(1350); 11922 inputTag(); 11923 } 11924 break; 11925 case 11: 11926 enterOuterAlt(_localctx, 11); 11927 { 11928 setState(1351); 11929 isindexTag(); 11930 } 11931 break; 11932 case 12: 11933 enterOuterAlt(_localctx, 12); 11934 { 11935 setState(1352); 11936 linkTag(); 11937 } 11938 break; 11939 case 13: 11940 enterOuterAlt(_localctx, 13); 11941 { 11942 setState(1353); 11943 metaTag(); 11944 } 11945 break; 11946 case 14: 11947 enterOuterAlt(_localctx, 14); 11948 { 11949 setState(1354); 11950 paramTag(); 11951 } 11952 break; 11953 case 15: 11954 enterOuterAlt(_localctx, 15); 11955 { 11956 setState(1355); 11957 wrongSinletonTag(); 11958 } 11959 break; 11960 } 11961 } 11962 catch (RecognitionException re) { 11963 _localctx.exception = re; 11964 _errHandler.reportError(this, re); 11965 _errHandler.recover(this, re); 11966 } 11967 finally { 11968 exitRule(); 11969 } 11970 return _localctx; 11971 } 11972 11973 public static class SingletonTagContext extends ParserRuleContext { 11974 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11975 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 11976 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 11977 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 11978 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 11979 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 11980 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 11981 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 11982 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 11983 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 11984 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 11985 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 11986 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 11987 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 11988 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 11989 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 11990 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 11991 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11992 public List<AttributeContext> attribute() { 11993 return getRuleContexts(AttributeContext.class); 11994 } 11995 public AttributeContext attribute(int i) { 11996 return getRuleContext(AttributeContext.class,i); 11997 } 11998 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11999 public TerminalNode NEWLINE(int i) { 12000 return getToken(JavadocParser.NEWLINE, i); 12001 } 12002 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12003 public TerminalNode LEADING_ASTERISK(int i) { 12004 return getToken(JavadocParser.LEADING_ASTERISK, i); 12005 } 12006 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12007 public TerminalNode WS(int i) { 12008 return getToken(JavadocParser.WS, i); 12009 } 12010 public SingletonTagContext(ParserRuleContext parent, int invokingState) { 12011 super(parent, invokingState); 12012 } 12013 @Override public int getRuleIndex() { return RULE_singletonTag; } 12014 @Override 12015 public void enterRule(ParseTreeListener listener) { 12016 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTag(this); 12017 } 12018 @Override 12019 public void exitRule(ParseTreeListener listener) { 12020 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTag(this); 12021 } 12022 @Override 12023 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12024 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTag(this); 12025 else return visitor.visitChildren(this); 12026 } 12027 } 12028 12029 public final SingletonTagContext singletonTag() throws RecognitionException { 12030 SingletonTagContext _localctx = new SingletonTagContext(_ctx, getState()); 12031 enterRule(_localctx, 104, RULE_singletonTag); 12032 int _la; 12033 try { 12034 enterOuterAlt(_localctx, 1); 12035 { 12036 setState(1358); 12037 match(OPEN); 12038 setState(1359); 12039 _la = _input.LA(1); 12040 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)) ) { 12041 _errHandler.recoverInline(this); 12042 } 12043 else { 12044 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12045 _errHandler.reportMatch(this); 12046 consume(); 12047 } 12048 setState(1366); 12049 _errHandler.sync(this); 12050 _la = _input.LA(1); 12051 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12052 { 12053 setState(1364); 12054 _errHandler.sync(this); 12055 switch (_input.LA(1)) { 12056 case HTML_TAG_NAME: 12057 { 12058 setState(1360); 12059 attribute(); 12060 } 12061 break; 12062 case NEWLINE: 12063 { 12064 setState(1361); 12065 match(NEWLINE); 12066 } 12067 break; 12068 case LEADING_ASTERISK: 12069 { 12070 setState(1362); 12071 match(LEADING_ASTERISK); 12072 } 12073 break; 12074 case WS: 12075 { 12076 setState(1363); 12077 match(WS); 12078 } 12079 break; 12080 default: 12081 throw new NoViableAltException(this); 12082 } 12083 } 12084 setState(1368); 12085 _errHandler.sync(this); 12086 _la = _input.LA(1); 12087 } 12088 setState(1369); 12089 match(SLASH_CLOSE); 12090 } 12091 } 12092 catch (RecognitionException re) { 12093 _localctx.exception = re; 12094 _errHandler.reportError(this, re); 12095 _errHandler.recover(this, re); 12096 } 12097 finally { 12098 exitRule(); 12099 } 12100 return _localctx; 12101 } 12102 12103 public static class AreaTagContext extends ParserRuleContext { 12104 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12105 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 12106 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12107 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12108 public List<AttributeContext> attribute() { 12109 return getRuleContexts(AttributeContext.class); 12110 } 12111 public AttributeContext attribute(int i) { 12112 return getRuleContext(AttributeContext.class,i); 12113 } 12114 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12115 public TerminalNode NEWLINE(int i) { 12116 return getToken(JavadocParser.NEWLINE, i); 12117 } 12118 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12119 public TerminalNode LEADING_ASTERISK(int i) { 12120 return getToken(JavadocParser.LEADING_ASTERISK, i); 12121 } 12122 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12123 public TerminalNode WS(int i) { 12124 return getToken(JavadocParser.WS, i); 12125 } 12126 public AreaTagContext(ParserRuleContext parent, int invokingState) { 12127 super(parent, invokingState); 12128 } 12129 @Override public int getRuleIndex() { return RULE_areaTag; } 12130 @Override 12131 public void enterRule(ParseTreeListener listener) { 12132 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAreaTag(this); 12133 } 12134 @Override 12135 public void exitRule(ParseTreeListener listener) { 12136 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAreaTag(this); 12137 } 12138 @Override 12139 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12140 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAreaTag(this); 12141 else return visitor.visitChildren(this); 12142 } 12143 } 12144 12145 public final AreaTagContext areaTag() throws RecognitionException { 12146 AreaTagContext _localctx = new AreaTagContext(_ctx, getState()); 12147 enterRule(_localctx, 106, RULE_areaTag); 12148 int _la; 12149 try { 12150 enterOuterAlt(_localctx, 1); 12151 { 12152 setState(1371); 12153 match(OPEN); 12154 setState(1372); 12155 match(AREA_HTML_TAG_NAME); 12156 setState(1379); 12157 _errHandler.sync(this); 12158 _la = _input.LA(1); 12159 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12160 { 12161 setState(1377); 12162 _errHandler.sync(this); 12163 switch (_input.LA(1)) { 12164 case HTML_TAG_NAME: 12165 { 12166 setState(1373); 12167 attribute(); 12168 } 12169 break; 12170 case NEWLINE: 12171 { 12172 setState(1374); 12173 match(NEWLINE); 12174 } 12175 break; 12176 case LEADING_ASTERISK: 12177 { 12178 setState(1375); 12179 match(LEADING_ASTERISK); 12180 } 12181 break; 12182 case WS: 12183 { 12184 setState(1376); 12185 match(WS); 12186 } 12187 break; 12188 default: 12189 throw new NoViableAltException(this); 12190 } 12191 } 12192 setState(1381); 12193 _errHandler.sync(this); 12194 _la = _input.LA(1); 12195 } 12196 setState(1382); 12197 _la = _input.LA(1); 12198 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12199 _errHandler.recoverInline(this); 12200 } 12201 else { 12202 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12203 _errHandler.reportMatch(this); 12204 consume(); 12205 } 12206 } 12207 } 12208 catch (RecognitionException re) { 12209 _localctx.exception = re; 12210 _errHandler.reportError(this, re); 12211 _errHandler.recover(this, re); 12212 } 12213 finally { 12214 exitRule(); 12215 } 12216 return _localctx; 12217 } 12218 12219 public static class BaseTagContext extends ParserRuleContext { 12220 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12221 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 12222 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12223 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12224 public List<AttributeContext> attribute() { 12225 return getRuleContexts(AttributeContext.class); 12226 } 12227 public AttributeContext attribute(int i) { 12228 return getRuleContext(AttributeContext.class,i); 12229 } 12230 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12231 public TerminalNode NEWLINE(int i) { 12232 return getToken(JavadocParser.NEWLINE, i); 12233 } 12234 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12235 public TerminalNode LEADING_ASTERISK(int i) { 12236 return getToken(JavadocParser.LEADING_ASTERISK, i); 12237 } 12238 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12239 public TerminalNode WS(int i) { 12240 return getToken(JavadocParser.WS, i); 12241 } 12242 public BaseTagContext(ParserRuleContext parent, int invokingState) { 12243 super(parent, invokingState); 12244 } 12245 @Override public int getRuleIndex() { return RULE_baseTag; } 12246 @Override 12247 public void enterRule(ParseTreeListener listener) { 12248 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBaseTag(this); 12249 } 12250 @Override 12251 public void exitRule(ParseTreeListener listener) { 12252 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBaseTag(this); 12253 } 12254 @Override 12255 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12256 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBaseTag(this); 12257 else return visitor.visitChildren(this); 12258 } 12259 } 12260 12261 public final BaseTagContext baseTag() throws RecognitionException { 12262 BaseTagContext _localctx = new BaseTagContext(_ctx, getState()); 12263 enterRule(_localctx, 108, RULE_baseTag); 12264 int _la; 12265 try { 12266 enterOuterAlt(_localctx, 1); 12267 { 12268 setState(1384); 12269 match(OPEN); 12270 setState(1385); 12271 match(BASE_HTML_TAG_NAME); 12272 setState(1392); 12273 _errHandler.sync(this); 12274 _la = _input.LA(1); 12275 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12276 { 12277 setState(1390); 12278 _errHandler.sync(this); 12279 switch (_input.LA(1)) { 12280 case HTML_TAG_NAME: 12281 { 12282 setState(1386); 12283 attribute(); 12284 } 12285 break; 12286 case NEWLINE: 12287 { 12288 setState(1387); 12289 match(NEWLINE); 12290 } 12291 break; 12292 case LEADING_ASTERISK: 12293 { 12294 setState(1388); 12295 match(LEADING_ASTERISK); 12296 } 12297 break; 12298 case WS: 12299 { 12300 setState(1389); 12301 match(WS); 12302 } 12303 break; 12304 default: 12305 throw new NoViableAltException(this); 12306 } 12307 } 12308 setState(1394); 12309 _errHandler.sync(this); 12310 _la = _input.LA(1); 12311 } 12312 setState(1395); 12313 _la = _input.LA(1); 12314 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12315 _errHandler.recoverInline(this); 12316 } 12317 else { 12318 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12319 _errHandler.reportMatch(this); 12320 consume(); 12321 } 12322 } 12323 } 12324 catch (RecognitionException re) { 12325 _localctx.exception = re; 12326 _errHandler.reportError(this, re); 12327 _errHandler.recover(this, re); 12328 } 12329 finally { 12330 exitRule(); 12331 } 12332 return _localctx; 12333 } 12334 12335 public static class BasefontTagContext extends ParserRuleContext { 12336 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12337 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 12338 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12339 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12340 public List<AttributeContext> attribute() { 12341 return getRuleContexts(AttributeContext.class); 12342 } 12343 public AttributeContext attribute(int i) { 12344 return getRuleContext(AttributeContext.class,i); 12345 } 12346 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12347 public TerminalNode NEWLINE(int i) { 12348 return getToken(JavadocParser.NEWLINE, i); 12349 } 12350 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12351 public TerminalNode LEADING_ASTERISK(int i) { 12352 return getToken(JavadocParser.LEADING_ASTERISK, i); 12353 } 12354 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12355 public TerminalNode WS(int i) { 12356 return getToken(JavadocParser.WS, i); 12357 } 12358 public BasefontTagContext(ParserRuleContext parent, int invokingState) { 12359 super(parent, invokingState); 12360 } 12361 @Override public int getRuleIndex() { return RULE_basefontTag; } 12362 @Override 12363 public void enterRule(ParseTreeListener listener) { 12364 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBasefontTag(this); 12365 } 12366 @Override 12367 public void exitRule(ParseTreeListener listener) { 12368 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBasefontTag(this); 12369 } 12370 @Override 12371 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12372 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBasefontTag(this); 12373 else return visitor.visitChildren(this); 12374 } 12375 } 12376 12377 public final BasefontTagContext basefontTag() throws RecognitionException { 12378 BasefontTagContext _localctx = new BasefontTagContext(_ctx, getState()); 12379 enterRule(_localctx, 110, RULE_basefontTag); 12380 int _la; 12381 try { 12382 enterOuterAlt(_localctx, 1); 12383 { 12384 setState(1397); 12385 match(OPEN); 12386 setState(1398); 12387 match(BASEFONT_HTML_TAG_NAME); 12388 setState(1405); 12389 _errHandler.sync(this); 12390 _la = _input.LA(1); 12391 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12392 { 12393 setState(1403); 12394 _errHandler.sync(this); 12395 switch (_input.LA(1)) { 12396 case HTML_TAG_NAME: 12397 { 12398 setState(1399); 12399 attribute(); 12400 } 12401 break; 12402 case NEWLINE: 12403 { 12404 setState(1400); 12405 match(NEWLINE); 12406 } 12407 break; 12408 case LEADING_ASTERISK: 12409 { 12410 setState(1401); 12411 match(LEADING_ASTERISK); 12412 } 12413 break; 12414 case WS: 12415 { 12416 setState(1402); 12417 match(WS); 12418 } 12419 break; 12420 default: 12421 throw new NoViableAltException(this); 12422 } 12423 } 12424 setState(1407); 12425 _errHandler.sync(this); 12426 _la = _input.LA(1); 12427 } 12428 setState(1408); 12429 _la = _input.LA(1); 12430 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12431 _errHandler.recoverInline(this); 12432 } 12433 else { 12434 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12435 _errHandler.reportMatch(this); 12436 consume(); 12437 } 12438 } 12439 } 12440 catch (RecognitionException re) { 12441 _localctx.exception = re; 12442 _errHandler.reportError(this, re); 12443 _errHandler.recover(this, re); 12444 } 12445 finally { 12446 exitRule(); 12447 } 12448 return _localctx; 12449 } 12450 12451 public static class BrTagContext extends ParserRuleContext { 12452 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12453 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 12454 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12455 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12456 public List<AttributeContext> attribute() { 12457 return getRuleContexts(AttributeContext.class); 12458 } 12459 public AttributeContext attribute(int i) { 12460 return getRuleContext(AttributeContext.class,i); 12461 } 12462 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12463 public TerminalNode NEWLINE(int i) { 12464 return getToken(JavadocParser.NEWLINE, i); 12465 } 12466 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12467 public TerminalNode LEADING_ASTERISK(int i) { 12468 return getToken(JavadocParser.LEADING_ASTERISK, i); 12469 } 12470 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12471 public TerminalNode WS(int i) { 12472 return getToken(JavadocParser.WS, i); 12473 } 12474 public BrTagContext(ParserRuleContext parent, int invokingState) { 12475 super(parent, invokingState); 12476 } 12477 @Override public int getRuleIndex() { return RULE_brTag; } 12478 @Override 12479 public void enterRule(ParseTreeListener listener) { 12480 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBrTag(this); 12481 } 12482 @Override 12483 public void exitRule(ParseTreeListener listener) { 12484 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBrTag(this); 12485 } 12486 @Override 12487 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12488 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBrTag(this); 12489 else return visitor.visitChildren(this); 12490 } 12491 } 12492 12493 public final BrTagContext brTag() throws RecognitionException { 12494 BrTagContext _localctx = new BrTagContext(_ctx, getState()); 12495 enterRule(_localctx, 112, RULE_brTag); 12496 int _la; 12497 try { 12498 enterOuterAlt(_localctx, 1); 12499 { 12500 setState(1410); 12501 match(OPEN); 12502 setState(1411); 12503 match(BR_HTML_TAG_NAME); 12504 setState(1418); 12505 _errHandler.sync(this); 12506 _la = _input.LA(1); 12507 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12508 { 12509 setState(1416); 12510 _errHandler.sync(this); 12511 switch (_input.LA(1)) { 12512 case HTML_TAG_NAME: 12513 { 12514 setState(1412); 12515 attribute(); 12516 } 12517 break; 12518 case NEWLINE: 12519 { 12520 setState(1413); 12521 match(NEWLINE); 12522 } 12523 break; 12524 case LEADING_ASTERISK: 12525 { 12526 setState(1414); 12527 match(LEADING_ASTERISK); 12528 } 12529 break; 12530 case WS: 12531 { 12532 setState(1415); 12533 match(WS); 12534 } 12535 break; 12536 default: 12537 throw new NoViableAltException(this); 12538 } 12539 } 12540 setState(1420); 12541 _errHandler.sync(this); 12542 _la = _input.LA(1); 12543 } 12544 setState(1421); 12545 _la = _input.LA(1); 12546 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12547 _errHandler.recoverInline(this); 12548 } 12549 else { 12550 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12551 _errHandler.reportMatch(this); 12552 consume(); 12553 } 12554 } 12555 } 12556 catch (RecognitionException re) { 12557 _localctx.exception = re; 12558 _errHandler.reportError(this, re); 12559 _errHandler.recover(this, re); 12560 } 12561 finally { 12562 exitRule(); 12563 } 12564 return _localctx; 12565 } 12566 12567 public static class ColTagContext extends ParserRuleContext { 12568 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12569 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 12570 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12571 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12572 public List<AttributeContext> attribute() { 12573 return getRuleContexts(AttributeContext.class); 12574 } 12575 public AttributeContext attribute(int i) { 12576 return getRuleContext(AttributeContext.class,i); 12577 } 12578 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12579 public TerminalNode NEWLINE(int i) { 12580 return getToken(JavadocParser.NEWLINE, i); 12581 } 12582 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12583 public TerminalNode LEADING_ASTERISK(int i) { 12584 return getToken(JavadocParser.LEADING_ASTERISK, i); 12585 } 12586 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12587 public TerminalNode WS(int i) { 12588 return getToken(JavadocParser.WS, i); 12589 } 12590 public ColTagContext(ParserRuleContext parent, int invokingState) { 12591 super(parent, invokingState); 12592 } 12593 @Override public int getRuleIndex() { return RULE_colTag; } 12594 @Override 12595 public void enterRule(ParseTreeListener listener) { 12596 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColTag(this); 12597 } 12598 @Override 12599 public void exitRule(ParseTreeListener listener) { 12600 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColTag(this); 12601 } 12602 @Override 12603 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12604 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColTag(this); 12605 else return visitor.visitChildren(this); 12606 } 12607 } 12608 12609 public final ColTagContext colTag() throws RecognitionException { 12610 ColTagContext _localctx = new ColTagContext(_ctx, getState()); 12611 enterRule(_localctx, 114, RULE_colTag); 12612 int _la; 12613 try { 12614 enterOuterAlt(_localctx, 1); 12615 { 12616 setState(1423); 12617 match(OPEN); 12618 setState(1424); 12619 match(COL_HTML_TAG_NAME); 12620 setState(1431); 12621 _errHandler.sync(this); 12622 _la = _input.LA(1); 12623 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12624 { 12625 setState(1429); 12626 _errHandler.sync(this); 12627 switch (_input.LA(1)) { 12628 case HTML_TAG_NAME: 12629 { 12630 setState(1425); 12631 attribute(); 12632 } 12633 break; 12634 case NEWLINE: 12635 { 12636 setState(1426); 12637 match(NEWLINE); 12638 } 12639 break; 12640 case LEADING_ASTERISK: 12641 { 12642 setState(1427); 12643 match(LEADING_ASTERISK); 12644 } 12645 break; 12646 case WS: 12647 { 12648 setState(1428); 12649 match(WS); 12650 } 12651 break; 12652 default: 12653 throw new NoViableAltException(this); 12654 } 12655 } 12656 setState(1433); 12657 _errHandler.sync(this); 12658 _la = _input.LA(1); 12659 } 12660 setState(1434); 12661 _la = _input.LA(1); 12662 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12663 _errHandler.recoverInline(this); 12664 } 12665 else { 12666 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12667 _errHandler.reportMatch(this); 12668 consume(); 12669 } 12670 } 12671 } 12672 catch (RecognitionException re) { 12673 _localctx.exception = re; 12674 _errHandler.reportError(this, re); 12675 _errHandler.recover(this, re); 12676 } 12677 finally { 12678 exitRule(); 12679 } 12680 return _localctx; 12681 } 12682 12683 public static class FrameTagContext extends ParserRuleContext { 12684 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12685 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 12686 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12687 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12688 public List<AttributeContext> attribute() { 12689 return getRuleContexts(AttributeContext.class); 12690 } 12691 public AttributeContext attribute(int i) { 12692 return getRuleContext(AttributeContext.class,i); 12693 } 12694 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12695 public TerminalNode NEWLINE(int i) { 12696 return getToken(JavadocParser.NEWLINE, i); 12697 } 12698 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12699 public TerminalNode LEADING_ASTERISK(int i) { 12700 return getToken(JavadocParser.LEADING_ASTERISK, i); 12701 } 12702 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12703 public TerminalNode WS(int i) { 12704 return getToken(JavadocParser.WS, i); 12705 } 12706 public FrameTagContext(ParserRuleContext parent, int invokingState) { 12707 super(parent, invokingState); 12708 } 12709 @Override public int getRuleIndex() { return RULE_frameTag; } 12710 @Override 12711 public void enterRule(ParseTreeListener listener) { 12712 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterFrameTag(this); 12713 } 12714 @Override 12715 public void exitRule(ParseTreeListener listener) { 12716 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitFrameTag(this); 12717 } 12718 @Override 12719 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12720 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitFrameTag(this); 12721 else return visitor.visitChildren(this); 12722 } 12723 } 12724 12725 public final FrameTagContext frameTag() throws RecognitionException { 12726 FrameTagContext _localctx = new FrameTagContext(_ctx, getState()); 12727 enterRule(_localctx, 116, RULE_frameTag); 12728 int _la; 12729 try { 12730 enterOuterAlt(_localctx, 1); 12731 { 12732 setState(1436); 12733 match(OPEN); 12734 setState(1437); 12735 match(FRAME_HTML_TAG_NAME); 12736 setState(1444); 12737 _errHandler.sync(this); 12738 _la = _input.LA(1); 12739 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12740 { 12741 setState(1442); 12742 _errHandler.sync(this); 12743 switch (_input.LA(1)) { 12744 case HTML_TAG_NAME: 12745 { 12746 setState(1438); 12747 attribute(); 12748 } 12749 break; 12750 case NEWLINE: 12751 { 12752 setState(1439); 12753 match(NEWLINE); 12754 } 12755 break; 12756 case LEADING_ASTERISK: 12757 { 12758 setState(1440); 12759 match(LEADING_ASTERISK); 12760 } 12761 break; 12762 case WS: 12763 { 12764 setState(1441); 12765 match(WS); 12766 } 12767 break; 12768 default: 12769 throw new NoViableAltException(this); 12770 } 12771 } 12772 setState(1446); 12773 _errHandler.sync(this); 12774 _la = _input.LA(1); 12775 } 12776 setState(1447); 12777 _la = _input.LA(1); 12778 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12779 _errHandler.recoverInline(this); 12780 } 12781 else { 12782 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12783 _errHandler.reportMatch(this); 12784 consume(); 12785 } 12786 } 12787 } 12788 catch (RecognitionException re) { 12789 _localctx.exception = re; 12790 _errHandler.reportError(this, re); 12791 _errHandler.recover(this, re); 12792 } 12793 finally { 12794 exitRule(); 12795 } 12796 return _localctx; 12797 } 12798 12799 public static class HrTagContext extends ParserRuleContext { 12800 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12801 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 12802 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12803 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12804 public List<AttributeContext> attribute() { 12805 return getRuleContexts(AttributeContext.class); 12806 } 12807 public AttributeContext attribute(int i) { 12808 return getRuleContext(AttributeContext.class,i); 12809 } 12810 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12811 public TerminalNode NEWLINE(int i) { 12812 return getToken(JavadocParser.NEWLINE, i); 12813 } 12814 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12815 public TerminalNode LEADING_ASTERISK(int i) { 12816 return getToken(JavadocParser.LEADING_ASTERISK, i); 12817 } 12818 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12819 public TerminalNode WS(int i) { 12820 return getToken(JavadocParser.WS, i); 12821 } 12822 public HrTagContext(ParserRuleContext parent, int invokingState) { 12823 super(parent, invokingState); 12824 } 12825 @Override public int getRuleIndex() { return RULE_hrTag; } 12826 @Override 12827 public void enterRule(ParseTreeListener listener) { 12828 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHrTag(this); 12829 } 12830 @Override 12831 public void exitRule(ParseTreeListener listener) { 12832 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHrTag(this); 12833 } 12834 @Override 12835 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12836 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHrTag(this); 12837 else return visitor.visitChildren(this); 12838 } 12839 } 12840 12841 public final HrTagContext hrTag() throws RecognitionException { 12842 HrTagContext _localctx = new HrTagContext(_ctx, getState()); 12843 enterRule(_localctx, 118, RULE_hrTag); 12844 int _la; 12845 try { 12846 enterOuterAlt(_localctx, 1); 12847 { 12848 setState(1449); 12849 match(OPEN); 12850 setState(1450); 12851 match(HR_HTML_TAG_NAME); 12852 setState(1457); 12853 _errHandler.sync(this); 12854 _la = _input.LA(1); 12855 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12856 { 12857 setState(1455); 12858 _errHandler.sync(this); 12859 switch (_input.LA(1)) { 12860 case HTML_TAG_NAME: 12861 { 12862 setState(1451); 12863 attribute(); 12864 } 12865 break; 12866 case NEWLINE: 12867 { 12868 setState(1452); 12869 match(NEWLINE); 12870 } 12871 break; 12872 case LEADING_ASTERISK: 12873 { 12874 setState(1453); 12875 match(LEADING_ASTERISK); 12876 } 12877 break; 12878 case WS: 12879 { 12880 setState(1454); 12881 match(WS); 12882 } 12883 break; 12884 default: 12885 throw new NoViableAltException(this); 12886 } 12887 } 12888 setState(1459); 12889 _errHandler.sync(this); 12890 _la = _input.LA(1); 12891 } 12892 setState(1460); 12893 _la = _input.LA(1); 12894 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12895 _errHandler.recoverInline(this); 12896 } 12897 else { 12898 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 12899 _errHandler.reportMatch(this); 12900 consume(); 12901 } 12902 } 12903 } 12904 catch (RecognitionException re) { 12905 _localctx.exception = re; 12906 _errHandler.reportError(this, re); 12907 _errHandler.recover(this, re); 12908 } 12909 finally { 12910 exitRule(); 12911 } 12912 return _localctx; 12913 } 12914 12915 public static class ImgTagContext extends ParserRuleContext { 12916 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12917 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 12918 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12919 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12920 public List<AttributeContext> attribute() { 12921 return getRuleContexts(AttributeContext.class); 12922 } 12923 public AttributeContext attribute(int i) { 12924 return getRuleContext(AttributeContext.class,i); 12925 } 12926 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12927 public TerminalNode NEWLINE(int i) { 12928 return getToken(JavadocParser.NEWLINE, i); 12929 } 12930 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12931 public TerminalNode LEADING_ASTERISK(int i) { 12932 return getToken(JavadocParser.LEADING_ASTERISK, i); 12933 } 12934 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12935 public TerminalNode WS(int i) { 12936 return getToken(JavadocParser.WS, i); 12937 } 12938 public ImgTagContext(ParserRuleContext parent, int invokingState) { 12939 super(parent, invokingState); 12940 } 12941 @Override public int getRuleIndex() { return RULE_imgTag; } 12942 @Override 12943 public void enterRule(ParseTreeListener listener) { 12944 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterImgTag(this); 12945 } 12946 @Override 12947 public void exitRule(ParseTreeListener listener) { 12948 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitImgTag(this); 12949 } 12950 @Override 12951 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12952 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitImgTag(this); 12953 else return visitor.visitChildren(this); 12954 } 12955 } 12956 12957 public final ImgTagContext imgTag() throws RecognitionException { 12958 ImgTagContext _localctx = new ImgTagContext(_ctx, getState()); 12959 enterRule(_localctx, 120, RULE_imgTag); 12960 int _la; 12961 try { 12962 enterOuterAlt(_localctx, 1); 12963 { 12964 setState(1462); 12965 match(OPEN); 12966 setState(1463); 12967 match(IMG_HTML_TAG_NAME); 12968 setState(1470); 12969 _errHandler.sync(this); 12970 _la = _input.LA(1); 12971 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12972 { 12973 setState(1468); 12974 _errHandler.sync(this); 12975 switch (_input.LA(1)) { 12976 case HTML_TAG_NAME: 12977 { 12978 setState(1464); 12979 attribute(); 12980 } 12981 break; 12982 case NEWLINE: 12983 { 12984 setState(1465); 12985 match(NEWLINE); 12986 } 12987 break; 12988 case LEADING_ASTERISK: 12989 { 12990 setState(1466); 12991 match(LEADING_ASTERISK); 12992 } 12993 break; 12994 case WS: 12995 { 12996 setState(1467); 12997 match(WS); 12998 } 12999 break; 13000 default: 13001 throw new NoViableAltException(this); 13002 } 13003 } 13004 setState(1472); 13005 _errHandler.sync(this); 13006 _la = _input.LA(1); 13007 } 13008 setState(1473); 13009 _la = _input.LA(1); 13010 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13011 _errHandler.recoverInline(this); 13012 } 13013 else { 13014 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13015 _errHandler.reportMatch(this); 13016 consume(); 13017 } 13018 } 13019 } 13020 catch (RecognitionException re) { 13021 _localctx.exception = re; 13022 _errHandler.reportError(this, re); 13023 _errHandler.recover(this, re); 13024 } 13025 finally { 13026 exitRule(); 13027 } 13028 return _localctx; 13029 } 13030 13031 public static class InputTagContext extends ParserRuleContext { 13032 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13033 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 13034 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13035 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13036 public List<AttributeContext> attribute() { 13037 return getRuleContexts(AttributeContext.class); 13038 } 13039 public AttributeContext attribute(int i) { 13040 return getRuleContext(AttributeContext.class,i); 13041 } 13042 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13043 public TerminalNode NEWLINE(int i) { 13044 return getToken(JavadocParser.NEWLINE, i); 13045 } 13046 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13047 public TerminalNode LEADING_ASTERISK(int i) { 13048 return getToken(JavadocParser.LEADING_ASTERISK, i); 13049 } 13050 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13051 public TerminalNode WS(int i) { 13052 return getToken(JavadocParser.WS, i); 13053 } 13054 public InputTagContext(ParserRuleContext parent, int invokingState) { 13055 super(parent, invokingState); 13056 } 13057 @Override public int getRuleIndex() { return RULE_inputTag; } 13058 @Override 13059 public void enterRule(ParseTreeListener listener) { 13060 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInputTag(this); 13061 } 13062 @Override 13063 public void exitRule(ParseTreeListener listener) { 13064 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInputTag(this); 13065 } 13066 @Override 13067 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13068 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInputTag(this); 13069 else return visitor.visitChildren(this); 13070 } 13071 } 13072 13073 public final InputTagContext inputTag() throws RecognitionException { 13074 InputTagContext _localctx = new InputTagContext(_ctx, getState()); 13075 enterRule(_localctx, 122, RULE_inputTag); 13076 int _la; 13077 try { 13078 enterOuterAlt(_localctx, 1); 13079 { 13080 setState(1475); 13081 match(OPEN); 13082 setState(1476); 13083 match(INPUT_HTML_TAG_NAME); 13084 setState(1483); 13085 _errHandler.sync(this); 13086 _la = _input.LA(1); 13087 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13088 { 13089 setState(1481); 13090 _errHandler.sync(this); 13091 switch (_input.LA(1)) { 13092 case HTML_TAG_NAME: 13093 { 13094 setState(1477); 13095 attribute(); 13096 } 13097 break; 13098 case NEWLINE: 13099 { 13100 setState(1478); 13101 match(NEWLINE); 13102 } 13103 break; 13104 case LEADING_ASTERISK: 13105 { 13106 setState(1479); 13107 match(LEADING_ASTERISK); 13108 } 13109 break; 13110 case WS: 13111 { 13112 setState(1480); 13113 match(WS); 13114 } 13115 break; 13116 default: 13117 throw new NoViableAltException(this); 13118 } 13119 } 13120 setState(1485); 13121 _errHandler.sync(this); 13122 _la = _input.LA(1); 13123 } 13124 setState(1486); 13125 _la = _input.LA(1); 13126 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13127 _errHandler.recoverInline(this); 13128 } 13129 else { 13130 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13131 _errHandler.reportMatch(this); 13132 consume(); 13133 } 13134 } 13135 } 13136 catch (RecognitionException re) { 13137 _localctx.exception = re; 13138 _errHandler.reportError(this, re); 13139 _errHandler.recover(this, re); 13140 } 13141 finally { 13142 exitRule(); 13143 } 13144 return _localctx; 13145 } 13146 13147 public static class IsindexTagContext extends ParserRuleContext { 13148 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13149 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 13150 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13151 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13152 public List<AttributeContext> attribute() { 13153 return getRuleContexts(AttributeContext.class); 13154 } 13155 public AttributeContext attribute(int i) { 13156 return getRuleContext(AttributeContext.class,i); 13157 } 13158 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13159 public TerminalNode NEWLINE(int i) { 13160 return getToken(JavadocParser.NEWLINE, i); 13161 } 13162 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13163 public TerminalNode LEADING_ASTERISK(int i) { 13164 return getToken(JavadocParser.LEADING_ASTERISK, i); 13165 } 13166 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13167 public TerminalNode WS(int i) { 13168 return getToken(JavadocParser.WS, i); 13169 } 13170 public IsindexTagContext(ParserRuleContext parent, int invokingState) { 13171 super(parent, invokingState); 13172 } 13173 @Override public int getRuleIndex() { return RULE_isindexTag; } 13174 @Override 13175 public void enterRule(ParseTreeListener listener) { 13176 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterIsindexTag(this); 13177 } 13178 @Override 13179 public void exitRule(ParseTreeListener listener) { 13180 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitIsindexTag(this); 13181 } 13182 @Override 13183 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13184 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitIsindexTag(this); 13185 else return visitor.visitChildren(this); 13186 } 13187 } 13188 13189 public final IsindexTagContext isindexTag() throws RecognitionException { 13190 IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState()); 13191 enterRule(_localctx, 124, RULE_isindexTag); 13192 int _la; 13193 try { 13194 enterOuterAlt(_localctx, 1); 13195 { 13196 setState(1488); 13197 match(OPEN); 13198 setState(1489); 13199 match(ISINDEX_HTML_TAG_NAME); 13200 setState(1496); 13201 _errHandler.sync(this); 13202 _la = _input.LA(1); 13203 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13204 { 13205 setState(1494); 13206 _errHandler.sync(this); 13207 switch (_input.LA(1)) { 13208 case HTML_TAG_NAME: 13209 { 13210 setState(1490); 13211 attribute(); 13212 } 13213 break; 13214 case NEWLINE: 13215 { 13216 setState(1491); 13217 match(NEWLINE); 13218 } 13219 break; 13220 case LEADING_ASTERISK: 13221 { 13222 setState(1492); 13223 match(LEADING_ASTERISK); 13224 } 13225 break; 13226 case WS: 13227 { 13228 setState(1493); 13229 match(WS); 13230 } 13231 break; 13232 default: 13233 throw new NoViableAltException(this); 13234 } 13235 } 13236 setState(1498); 13237 _errHandler.sync(this); 13238 _la = _input.LA(1); 13239 } 13240 setState(1499); 13241 _la = _input.LA(1); 13242 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13243 _errHandler.recoverInline(this); 13244 } 13245 else { 13246 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13247 _errHandler.reportMatch(this); 13248 consume(); 13249 } 13250 } 13251 } 13252 catch (RecognitionException re) { 13253 _localctx.exception = re; 13254 _errHandler.reportError(this, re); 13255 _errHandler.recover(this, re); 13256 } 13257 finally { 13258 exitRule(); 13259 } 13260 return _localctx; 13261 } 13262 13263 public static class LinkTagContext extends ParserRuleContext { 13264 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13265 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 13266 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13267 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13268 public List<AttributeContext> attribute() { 13269 return getRuleContexts(AttributeContext.class); 13270 } 13271 public AttributeContext attribute(int i) { 13272 return getRuleContext(AttributeContext.class,i); 13273 } 13274 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13275 public TerminalNode NEWLINE(int i) { 13276 return getToken(JavadocParser.NEWLINE, i); 13277 } 13278 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13279 public TerminalNode LEADING_ASTERISK(int i) { 13280 return getToken(JavadocParser.LEADING_ASTERISK, i); 13281 } 13282 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13283 public TerminalNode WS(int i) { 13284 return getToken(JavadocParser.WS, i); 13285 } 13286 public LinkTagContext(ParserRuleContext parent, int invokingState) { 13287 super(parent, invokingState); 13288 } 13289 @Override public int getRuleIndex() { return RULE_linkTag; } 13290 @Override 13291 public void enterRule(ParseTreeListener listener) { 13292 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLinkTag(this); 13293 } 13294 @Override 13295 public void exitRule(ParseTreeListener listener) { 13296 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLinkTag(this); 13297 } 13298 @Override 13299 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13300 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLinkTag(this); 13301 else return visitor.visitChildren(this); 13302 } 13303 } 13304 13305 public final LinkTagContext linkTag() throws RecognitionException { 13306 LinkTagContext _localctx = new LinkTagContext(_ctx, getState()); 13307 enterRule(_localctx, 126, RULE_linkTag); 13308 int _la; 13309 try { 13310 enterOuterAlt(_localctx, 1); 13311 { 13312 setState(1501); 13313 match(OPEN); 13314 setState(1502); 13315 match(LINK_HTML_TAG_NAME); 13316 setState(1509); 13317 _errHandler.sync(this); 13318 _la = _input.LA(1); 13319 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13320 { 13321 setState(1507); 13322 _errHandler.sync(this); 13323 switch (_input.LA(1)) { 13324 case HTML_TAG_NAME: 13325 { 13326 setState(1503); 13327 attribute(); 13328 } 13329 break; 13330 case NEWLINE: 13331 { 13332 setState(1504); 13333 match(NEWLINE); 13334 } 13335 break; 13336 case LEADING_ASTERISK: 13337 { 13338 setState(1505); 13339 match(LEADING_ASTERISK); 13340 } 13341 break; 13342 case WS: 13343 { 13344 setState(1506); 13345 match(WS); 13346 } 13347 break; 13348 default: 13349 throw new NoViableAltException(this); 13350 } 13351 } 13352 setState(1511); 13353 _errHandler.sync(this); 13354 _la = _input.LA(1); 13355 } 13356 setState(1512); 13357 _la = _input.LA(1); 13358 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13359 _errHandler.recoverInline(this); 13360 } 13361 else { 13362 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13363 _errHandler.reportMatch(this); 13364 consume(); 13365 } 13366 } 13367 } 13368 catch (RecognitionException re) { 13369 _localctx.exception = re; 13370 _errHandler.reportError(this, re); 13371 _errHandler.recover(this, re); 13372 } 13373 finally { 13374 exitRule(); 13375 } 13376 return _localctx; 13377 } 13378 13379 public static class MetaTagContext extends ParserRuleContext { 13380 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13381 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 13382 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13383 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13384 public List<AttributeContext> attribute() { 13385 return getRuleContexts(AttributeContext.class); 13386 } 13387 public AttributeContext attribute(int i) { 13388 return getRuleContext(AttributeContext.class,i); 13389 } 13390 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13391 public TerminalNode NEWLINE(int i) { 13392 return getToken(JavadocParser.NEWLINE, i); 13393 } 13394 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13395 public TerminalNode LEADING_ASTERISK(int i) { 13396 return getToken(JavadocParser.LEADING_ASTERISK, i); 13397 } 13398 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13399 public TerminalNode WS(int i) { 13400 return getToken(JavadocParser.WS, i); 13401 } 13402 public MetaTagContext(ParserRuleContext parent, int invokingState) { 13403 super(parent, invokingState); 13404 } 13405 @Override public int getRuleIndex() { return RULE_metaTag; } 13406 @Override 13407 public void enterRule(ParseTreeListener listener) { 13408 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterMetaTag(this); 13409 } 13410 @Override 13411 public void exitRule(ParseTreeListener listener) { 13412 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitMetaTag(this); 13413 } 13414 @Override 13415 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13416 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitMetaTag(this); 13417 else return visitor.visitChildren(this); 13418 } 13419 } 13420 13421 public final MetaTagContext metaTag() throws RecognitionException { 13422 MetaTagContext _localctx = new MetaTagContext(_ctx, getState()); 13423 enterRule(_localctx, 128, RULE_metaTag); 13424 int _la; 13425 try { 13426 enterOuterAlt(_localctx, 1); 13427 { 13428 setState(1514); 13429 match(OPEN); 13430 setState(1515); 13431 match(META_HTML_TAG_NAME); 13432 setState(1522); 13433 _errHandler.sync(this); 13434 _la = _input.LA(1); 13435 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13436 { 13437 setState(1520); 13438 _errHandler.sync(this); 13439 switch (_input.LA(1)) { 13440 case HTML_TAG_NAME: 13441 { 13442 setState(1516); 13443 attribute(); 13444 } 13445 break; 13446 case NEWLINE: 13447 { 13448 setState(1517); 13449 match(NEWLINE); 13450 } 13451 break; 13452 case LEADING_ASTERISK: 13453 { 13454 setState(1518); 13455 match(LEADING_ASTERISK); 13456 } 13457 break; 13458 case WS: 13459 { 13460 setState(1519); 13461 match(WS); 13462 } 13463 break; 13464 default: 13465 throw new NoViableAltException(this); 13466 } 13467 } 13468 setState(1524); 13469 _errHandler.sync(this); 13470 _la = _input.LA(1); 13471 } 13472 setState(1525); 13473 _la = _input.LA(1); 13474 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13475 _errHandler.recoverInline(this); 13476 } 13477 else { 13478 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13479 _errHandler.reportMatch(this); 13480 consume(); 13481 } 13482 } 13483 } 13484 catch (RecognitionException re) { 13485 _localctx.exception = re; 13486 _errHandler.reportError(this, re); 13487 _errHandler.recover(this, re); 13488 } 13489 finally { 13490 exitRule(); 13491 } 13492 return _localctx; 13493 } 13494 13495 public static class ParamTagContext extends ParserRuleContext { 13496 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13497 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 13498 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13499 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13500 public List<AttributeContext> attribute() { 13501 return getRuleContexts(AttributeContext.class); 13502 } 13503 public AttributeContext attribute(int i) { 13504 return getRuleContext(AttributeContext.class,i); 13505 } 13506 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13507 public TerminalNode NEWLINE(int i) { 13508 return getToken(JavadocParser.NEWLINE, i); 13509 } 13510 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13511 public TerminalNode LEADING_ASTERISK(int i) { 13512 return getToken(JavadocParser.LEADING_ASTERISK, i); 13513 } 13514 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13515 public TerminalNode WS(int i) { 13516 return getToken(JavadocParser.WS, i); 13517 } 13518 public ParamTagContext(ParserRuleContext parent, int invokingState) { 13519 super(parent, invokingState); 13520 } 13521 @Override public int getRuleIndex() { return RULE_paramTag; } 13522 @Override 13523 public void enterRule(ParseTreeListener listener) { 13524 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParamTag(this); 13525 } 13526 @Override 13527 public void exitRule(ParseTreeListener listener) { 13528 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParamTag(this); 13529 } 13530 @Override 13531 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13532 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParamTag(this); 13533 else return visitor.visitChildren(this); 13534 } 13535 } 13536 13537 public final ParamTagContext paramTag() throws RecognitionException { 13538 ParamTagContext _localctx = new ParamTagContext(_ctx, getState()); 13539 enterRule(_localctx, 130, RULE_paramTag); 13540 int _la; 13541 try { 13542 enterOuterAlt(_localctx, 1); 13543 { 13544 setState(1527); 13545 match(OPEN); 13546 setState(1528); 13547 match(PARAM_HTML_TAG_NAME); 13548 setState(1535); 13549 _errHandler.sync(this); 13550 _la = _input.LA(1); 13551 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13552 { 13553 setState(1533); 13554 _errHandler.sync(this); 13555 switch (_input.LA(1)) { 13556 case HTML_TAG_NAME: 13557 { 13558 setState(1529); 13559 attribute(); 13560 } 13561 break; 13562 case NEWLINE: 13563 { 13564 setState(1530); 13565 match(NEWLINE); 13566 } 13567 break; 13568 case LEADING_ASTERISK: 13569 { 13570 setState(1531); 13571 match(LEADING_ASTERISK); 13572 } 13573 break; 13574 case WS: 13575 { 13576 setState(1532); 13577 match(WS); 13578 } 13579 break; 13580 default: 13581 throw new NoViableAltException(this); 13582 } 13583 } 13584 setState(1537); 13585 _errHandler.sync(this); 13586 _la = _input.LA(1); 13587 } 13588 setState(1538); 13589 _la = _input.LA(1); 13590 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13591 _errHandler.recoverInline(this); 13592 } 13593 else { 13594 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13595 _errHandler.reportMatch(this); 13596 consume(); 13597 } 13598 } 13599 } 13600 catch (RecognitionException re) { 13601 _localctx.exception = re; 13602 _errHandler.reportError(this, re); 13603 _errHandler.recover(this, re); 13604 } 13605 finally { 13606 exitRule(); 13607 } 13608 return _localctx; 13609 } 13610 13611 public static class WrongSinletonTagContext extends ParserRuleContext { 13612 public SingletonTagNameContext singletonTagName; 13613 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13614 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 13615 public SingletonTagNameContext singletonTagName() { 13616 return getRuleContext(SingletonTagNameContext.class,0); 13617 } 13618 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13619 public WrongSinletonTagContext(ParserRuleContext parent, int invokingState) { 13620 super(parent, invokingState); 13621 } 13622 @Override public int getRuleIndex() { return RULE_wrongSinletonTag; } 13623 @Override 13624 public void enterRule(ParseTreeListener listener) { 13625 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterWrongSinletonTag(this); 13626 } 13627 @Override 13628 public void exitRule(ParseTreeListener listener) { 13629 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitWrongSinletonTag(this); 13630 } 13631 @Override 13632 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13633 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWrongSinletonTag(this); 13634 else return visitor.visitChildren(this); 13635 } 13636 } 13637 13638 public final WrongSinletonTagContext wrongSinletonTag() throws RecognitionException { 13639 WrongSinletonTagContext _localctx = new WrongSinletonTagContext(_ctx, getState()); 13640 enterRule(_localctx, 132, RULE_wrongSinletonTag); 13641 try { 13642 enterOuterAlt(_localctx, 1); 13643 { 13644 setState(1540); 13645 match(OPEN); 13646 setState(1541); 13647 match(SLASH); 13648 setState(1542); 13649 ((WrongSinletonTagContext)_localctx).singletonTagName = singletonTagName(); 13650 setState(1543); 13651 match(CLOSE); 13652 notifyErrorListeners((((WrongSinletonTagContext)_localctx).singletonTagName!=null?(((WrongSinletonTagContext)_localctx).singletonTagName.start):null), 13653 "javadoc.wrong.singleton.html.tag", null); 13654 } 13655 } 13656 catch (RecognitionException re) { 13657 _localctx.exception = re; 13658 _errHandler.reportError(this, re); 13659 _errHandler.recover(this, re); 13660 } 13661 finally { 13662 exitRule(); 13663 } 13664 return _localctx; 13665 } 13666 13667 public static class SingletonTagNameContext extends ParserRuleContext { 13668 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 13669 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 13670 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 13671 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 13672 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 13673 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 13674 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 13675 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 13676 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 13677 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 13678 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 13679 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 13680 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 13681 public SingletonTagNameContext(ParserRuleContext parent, int invokingState) { 13682 super(parent, invokingState); 13683 } 13684 @Override public int getRuleIndex() { return RULE_singletonTagName; } 13685 @Override 13686 public void enterRule(ParseTreeListener listener) { 13687 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTagName(this); 13688 } 13689 @Override 13690 public void exitRule(ParseTreeListener listener) { 13691 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTagName(this); 13692 } 13693 @Override 13694 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13695 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTagName(this); 13696 else return visitor.visitChildren(this); 13697 } 13698 } 13699 13700 public final SingletonTagNameContext singletonTagName() throws RecognitionException { 13701 SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState()); 13702 enterRule(_localctx, 134, RULE_singletonTagName); 13703 int _la; 13704 try { 13705 enterOuterAlt(_localctx, 1); 13706 { 13707 setState(1546); 13708 _la = _input.LA(1); 13709 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)) ) { 13710 _errHandler.recoverInline(this); 13711 } 13712 else { 13713 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13714 _errHandler.reportMatch(this); 13715 consume(); 13716 } 13717 } 13718 } 13719 catch (RecognitionException re) { 13720 _localctx.exception = re; 13721 _errHandler.reportError(this, re); 13722 _errHandler.recover(this, re); 13723 } 13724 finally { 13725 exitRule(); 13726 } 13727 return _localctx; 13728 } 13729 13730 public static class DescriptionContext extends ParserRuleContext { 13731 public List<HtmlCommentContext> htmlComment() { 13732 return getRuleContexts(HtmlCommentContext.class); 13733 } 13734 public HtmlCommentContext htmlComment(int i) { 13735 return getRuleContext(HtmlCommentContext.class,i); 13736 } 13737 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 13738 public TerminalNode CDATA(int i) { 13739 return getToken(JavadocParser.CDATA, i); 13740 } 13741 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13742 public TerminalNode NEWLINE(int i) { 13743 return getToken(JavadocParser.NEWLINE, i); 13744 } 13745 public List<TextContext> text() { 13746 return getRuleContexts(TextContext.class); 13747 } 13748 public TextContext text(int i) { 13749 return getRuleContext(TextContext.class,i); 13750 } 13751 public List<JavadocInlineTagContext> javadocInlineTag() { 13752 return getRuleContexts(JavadocInlineTagContext.class); 13753 } 13754 public JavadocInlineTagContext javadocInlineTag(int i) { 13755 return getRuleContext(JavadocInlineTagContext.class,i); 13756 } 13757 public List<HtmlElementContext> htmlElement() { 13758 return getRuleContexts(HtmlElementContext.class); 13759 } 13760 public HtmlElementContext htmlElement(int i) { 13761 return getRuleContext(HtmlElementContext.class,i); 13762 } 13763 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13764 public TerminalNode LEADING_ASTERISK(int i) { 13765 return getToken(JavadocParser.LEADING_ASTERISK, i); 13766 } 13767 public DescriptionContext(ParserRuleContext parent, int invokingState) { 13768 super(parent, invokingState); 13769 } 13770 @Override public int getRuleIndex() { return RULE_description; } 13771 @Override 13772 public void enterRule(ParseTreeListener listener) { 13773 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescription(this); 13774 } 13775 @Override 13776 public void exitRule(ParseTreeListener listener) { 13777 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescription(this); 13778 } 13779 @Override 13780 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13781 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this); 13782 else return visitor.visitChildren(this); 13783 } 13784 } 13785 13786 public final DescriptionContext description() throws RecognitionException { 13787 DescriptionContext _localctx = new DescriptionContext(_ctx, getState()); 13788 enterRule(_localctx, 136, RULE_description); 13789 try { 13790 int _alt; 13791 enterOuterAlt(_localctx, 1); 13792 { 13793 setState(1556); 13794 _errHandler.sync(this); 13795 _alt = 1; 13796 do { 13797 switch (_alt) { 13798 case 1: 13799 { 13800 setState(1556); 13801 _errHandler.sync(this); 13802 switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) { 13803 case 1: 13804 { 13805 { 13806 setState(1548); 13807 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 13808 setState(1549); 13809 match(LEADING_ASTERISK); 13810 } 13811 } 13812 break; 13813 case 2: 13814 { 13815 setState(1550); 13816 htmlComment(); 13817 } 13818 break; 13819 case 3: 13820 { 13821 setState(1551); 13822 match(CDATA); 13823 } 13824 break; 13825 case 4: 13826 { 13827 setState(1552); 13828 match(NEWLINE); 13829 } 13830 break; 13831 case 5: 13832 { 13833 setState(1553); 13834 text(); 13835 } 13836 break; 13837 case 6: 13838 { 13839 setState(1554); 13840 javadocInlineTag(); 13841 } 13842 break; 13843 case 7: 13844 { 13845 setState(1555); 13846 htmlElement(); 13847 } 13848 break; 13849 } 13850 } 13851 break; 13852 default: 13853 throw new NoViableAltException(this); 13854 } 13855 setState(1558); 13856 _errHandler.sync(this); 13857 _alt = getInterpreter().adaptivePredict(_input,122,_ctx); 13858 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13859 } 13860 } 13861 catch (RecognitionException re) { 13862 _localctx.exception = re; 13863 _errHandler.reportError(this, re); 13864 _errHandler.recover(this, re); 13865 } 13866 finally { 13867 exitRule(); 13868 } 13869 return _localctx; 13870 } 13871 13872 public static class ReferenceContext extends ParserRuleContext { 13873 public TerminalNode PACKAGE() { return getToken(JavadocParser.PACKAGE, 0); } 13874 public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); } 13875 public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); } 13876 public ParametersContext parameters() { 13877 return getRuleContext(ParametersContext.class,0); 13878 } 13879 public List<TerminalNode> DOT() { return getTokens(JavadocParser.DOT); } 13880 public TerminalNode DOT(int i) { 13881 return getToken(JavadocParser.DOT, i); 13882 } 13883 public List<TerminalNode> CLASS() { return getTokens(JavadocParser.CLASS); } 13884 public TerminalNode CLASS(int i) { 13885 return getToken(JavadocParser.CLASS, i); 13886 } 13887 public ReferenceContext(ParserRuleContext parent, int invokingState) { 13888 super(parent, invokingState); 13889 } 13890 @Override public int getRuleIndex() { return RULE_reference; } 13891 @Override 13892 public void enterRule(ParseTreeListener listener) { 13893 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterReference(this); 13894 } 13895 @Override 13896 public void exitRule(ParseTreeListener listener) { 13897 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitReference(this); 13898 } 13899 @Override 13900 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13901 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitReference(this); 13902 else return visitor.visitChildren(this); 13903 } 13904 } 13905 13906 public final ReferenceContext reference() throws RecognitionException { 13907 ReferenceContext _localctx = new ReferenceContext(_ctx, getState()); 13908 enterRule(_localctx, 138, RULE_reference); 13909 int _la; 13910 try { 13911 int _alt; 13912 enterOuterAlt(_localctx, 1); 13913 { 13914 setState(1597); 13915 _errHandler.sync(this); 13916 switch (_input.LA(1)) { 13917 case PACKAGE: 13918 { 13919 setState(1560); 13920 match(PACKAGE); 13921 setState(1564); 13922 _errHandler.sync(this); 13923 _alt = getInterpreter().adaptivePredict(_input,123,_ctx); 13924 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13925 if ( _alt==1 ) { 13926 { 13927 { 13928 setState(1561); 13929 _la = _input.LA(1); 13930 if ( !(_la==DOT || _la==CLASS) ) { 13931 _errHandler.recoverInline(this); 13932 } 13933 else { 13934 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13935 _errHandler.reportMatch(this); 13936 consume(); 13937 } 13938 } 13939 } 13940 } 13941 setState(1566); 13942 _errHandler.sync(this); 13943 _alt = getInterpreter().adaptivePredict(_input,123,_ctx); 13944 } 13945 setState(1568); 13946 _errHandler.sync(this); 13947 switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) { 13948 case 1: 13949 { 13950 setState(1567); 13951 match(HASH); 13952 } 13953 break; 13954 } 13955 setState(1571); 13956 _errHandler.sync(this); 13957 switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) { 13958 case 1: 13959 { 13960 setState(1570); 13961 match(MEMBER); 13962 } 13963 break; 13964 } 13965 setState(1574); 13966 _errHandler.sync(this); 13967 switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) { 13968 case 1: 13969 { 13970 setState(1573); 13971 parameters(); 13972 } 13973 break; 13974 } 13975 } 13976 break; 13977 case DOT: 13978 case CLASS: 13979 { 13980 setState(1577); 13981 _errHandler.sync(this); 13982 _alt = 1; 13983 do { 13984 switch (_alt) { 13985 case 1: 13986 { 13987 { 13988 setState(1576); 13989 _la = _input.LA(1); 13990 if ( !(_la==DOT || _la==CLASS) ) { 13991 _errHandler.recoverInline(this); 13992 } 13993 else { 13994 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 13995 _errHandler.reportMatch(this); 13996 consume(); 13997 } 13998 } 13999 } 14000 break; 14001 default: 14002 throw new NoViableAltException(this); 14003 } 14004 setState(1579); 14005 _errHandler.sync(this); 14006 _alt = getInterpreter().adaptivePredict(_input,127,_ctx); 14007 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 14008 setState(1582); 14009 _errHandler.sync(this); 14010 switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { 14011 case 1: 14012 { 14013 setState(1581); 14014 match(HASH); 14015 } 14016 break; 14017 } 14018 setState(1585); 14019 _errHandler.sync(this); 14020 switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) { 14021 case 1: 14022 { 14023 setState(1584); 14024 match(MEMBER); 14025 } 14026 break; 14027 } 14028 setState(1588); 14029 _errHandler.sync(this); 14030 switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) { 14031 case 1: 14032 { 14033 setState(1587); 14034 parameters(); 14035 } 14036 break; 14037 } 14038 } 14039 break; 14040 case HASH: 14041 case MEMBER: 14042 { 14043 setState(1591); 14044 _errHandler.sync(this); 14045 _la = _input.LA(1); 14046 if (_la==HASH) { 14047 { 14048 setState(1590); 14049 match(HASH); 14050 } 14051 } 14052 14053 setState(1593); 14054 match(MEMBER); 14055 setState(1595); 14056 _errHandler.sync(this); 14057 switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { 14058 case 1: 14059 { 14060 setState(1594); 14061 parameters(); 14062 } 14063 break; 14064 } 14065 } 14066 break; 14067 default: 14068 throw new NoViableAltException(this); 14069 } 14070 } 14071 } 14072 catch (RecognitionException re) { 14073 _localctx.exception = re; 14074 _errHandler.reportError(this, re); 14075 _errHandler.recover(this, re); 14076 } 14077 finally { 14078 exitRule(); 14079 } 14080 return _localctx; 14081 } 14082 14083 public static class ParametersContext extends ParserRuleContext { 14084 public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); } 14085 public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); } 14086 public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); } 14087 public TerminalNode ARGUMENT(int i) { 14088 return getToken(JavadocParser.ARGUMENT, i); 14089 } 14090 public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); } 14091 public TerminalNode COMMA(int i) { 14092 return getToken(JavadocParser.COMMA, i); 14093 } 14094 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14095 public TerminalNode WS(int i) { 14096 return getToken(JavadocParser.WS, i); 14097 } 14098 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14099 public TerminalNode NEWLINE(int i) { 14100 return getToken(JavadocParser.NEWLINE, i); 14101 } 14102 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14103 public TerminalNode LEADING_ASTERISK(int i) { 14104 return getToken(JavadocParser.LEADING_ASTERISK, i); 14105 } 14106 public ParametersContext(ParserRuleContext parent, int invokingState) { 14107 super(parent, invokingState); 14108 } 14109 @Override public int getRuleIndex() { return RULE_parameters; } 14110 @Override 14111 public void enterRule(ParseTreeListener listener) { 14112 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParameters(this); 14113 } 14114 @Override 14115 public void exitRule(ParseTreeListener listener) { 14116 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParameters(this); 14117 } 14118 @Override 14119 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14120 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParameters(this); 14121 else return visitor.visitChildren(this); 14122 } 14123 } 14124 14125 public final ParametersContext parameters() throws RecognitionException { 14126 ParametersContext _localctx = new ParametersContext(_ctx, getState()); 14127 enterRule(_localctx, 140, RULE_parameters); 14128 int _la; 14129 try { 14130 enterOuterAlt(_localctx, 1); 14131 { 14132 setState(1599); 14133 match(LEFT_BRACE); 14134 setState(1603); 14135 _errHandler.sync(this); 14136 _la = _input.LA(1); 14137 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) { 14138 { 14139 { 14140 setState(1600); 14141 _la = _input.LA(1); 14142 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) { 14143 _errHandler.recoverInline(this); 14144 } 14145 else { 14146 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14147 _errHandler.reportMatch(this); 14148 consume(); 14149 } 14150 } 14151 } 14152 setState(1605); 14153 _errHandler.sync(this); 14154 _la = _input.LA(1); 14155 } 14156 setState(1606); 14157 match(RIGHT_BRACE); 14158 } 14159 } 14160 catch (RecognitionException re) { 14161 _localctx.exception = re; 14162 _errHandler.reportError(this, re); 14163 _errHandler.recover(this, re); 14164 } 14165 finally { 14166 exitRule(); 14167 } 14168 return _localctx; 14169 } 14170 14171 public static class JavadocTagContext extends ParserRuleContext { 14172 public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); } 14173 public DescriptionContext description() { 14174 return getRuleContext(DescriptionContext.class,0); 14175 } 14176 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14177 public TerminalNode WS(int i) { 14178 return getToken(JavadocParser.WS, i); 14179 } 14180 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14181 public TerminalNode NEWLINE(int i) { 14182 return getToken(JavadocParser.NEWLINE, i); 14183 } 14184 public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); } 14185 public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); } 14186 public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); } 14187 public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); } 14188 public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); } 14189 public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); } 14190 public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); } 14191 public ReferenceContext reference() { 14192 return getRuleContext(ReferenceContext.class,0); 14193 } 14194 public List<TerminalNode> STRING() { return getTokens(JavadocParser.STRING); } 14195 public TerminalNode STRING(int i) { 14196 return getToken(JavadocParser.STRING, i); 14197 } 14198 public List<HtmlElementContext> htmlElement() { 14199 return getRuleContexts(HtmlElementContext.class); 14200 } 14201 public HtmlElementContext htmlElement(int i) { 14202 return getRuleContext(HtmlElementContext.class,i); 14203 } 14204 public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); } 14205 public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); } 14206 public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); } 14207 public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); } 14208 public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); } 14209 public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); } 14210 public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); } 14211 public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); } 14212 public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); } 14213 public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); } 14214 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 14215 public JavadocTagContext(ParserRuleContext parent, int invokingState) { 14216 super(parent, invokingState); 14217 } 14218 @Override public int getRuleIndex() { return RULE_javadocTag; } 14219 @Override 14220 public void enterRule(ParseTreeListener listener) { 14221 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocTag(this); 14222 } 14223 @Override 14224 public void exitRule(ParseTreeListener listener) { 14225 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocTag(this); 14226 } 14227 @Override 14228 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14229 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocTag(this); 14230 else return visitor.visitChildren(this); 14231 } 14232 } 14233 14234 public final JavadocTagContext javadocTag() throws RecognitionException { 14235 JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState()); 14236 enterRule(_localctx, 142, RULE_javadocTag); 14237 int _la; 14238 try { 14239 int _alt; 14240 setState(1802); 14241 _errHandler.sync(this); 14242 switch (_input.LA(1)) { 14243 case AUTHOR_LITERAL: 14244 enterOuterAlt(_localctx, 1); 14245 { 14246 setState(1608); 14247 match(AUTHOR_LITERAL); 14248 setState(1612); 14249 _errHandler.sync(this); 14250 _alt = getInterpreter().adaptivePredict(_input,135,_ctx); 14251 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14252 if ( _alt==1 ) { 14253 { 14254 { 14255 setState(1609); 14256 _la = _input.LA(1); 14257 if ( !(_la==WS || _la==NEWLINE) ) { 14258 _errHandler.recoverInline(this); 14259 } 14260 else { 14261 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14262 _errHandler.reportMatch(this); 14263 consume(); 14264 } 14265 } 14266 } 14267 } 14268 setState(1614); 14269 _errHandler.sync(this); 14270 _alt = getInterpreter().adaptivePredict(_input,135,_ctx); 14271 } 14272 setState(1616); 14273 _errHandler.sync(this); 14274 switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) { 14275 case 1: 14276 { 14277 setState(1615); 14278 description(); 14279 } 14280 break; 14281 } 14282 } 14283 break; 14284 case DEPRECATED_LITERAL: 14285 enterOuterAlt(_localctx, 2); 14286 { 14287 setState(1618); 14288 match(DEPRECATED_LITERAL); 14289 setState(1622); 14290 _errHandler.sync(this); 14291 _alt = getInterpreter().adaptivePredict(_input,137,_ctx); 14292 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14293 if ( _alt==1 ) { 14294 { 14295 { 14296 setState(1619); 14297 _la = _input.LA(1); 14298 if ( !(_la==WS || _la==NEWLINE) ) { 14299 _errHandler.recoverInline(this); 14300 } 14301 else { 14302 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14303 _errHandler.reportMatch(this); 14304 consume(); 14305 } 14306 } 14307 } 14308 } 14309 setState(1624); 14310 _errHandler.sync(this); 14311 _alt = getInterpreter().adaptivePredict(_input,137,_ctx); 14312 } 14313 setState(1626); 14314 _errHandler.sync(this); 14315 switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { 14316 case 1: 14317 { 14318 setState(1625); 14319 description(); 14320 } 14321 break; 14322 } 14323 } 14324 break; 14325 case EXCEPTION_LITERAL: 14326 enterOuterAlt(_localctx, 3); 14327 { 14328 setState(1628); 14329 match(EXCEPTION_LITERAL); 14330 setState(1632); 14331 _errHandler.sync(this); 14332 _alt = getInterpreter().adaptivePredict(_input,139,_ctx); 14333 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14334 if ( _alt==1 ) { 14335 { 14336 { 14337 setState(1629); 14338 _la = _input.LA(1); 14339 if ( !(_la==WS || _la==NEWLINE) ) { 14340 _errHandler.recoverInline(this); 14341 } 14342 else { 14343 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14344 _errHandler.reportMatch(this); 14345 consume(); 14346 } 14347 } 14348 } 14349 } 14350 setState(1634); 14351 _errHandler.sync(this); 14352 _alt = getInterpreter().adaptivePredict(_input,139,_ctx); 14353 } 14354 setState(1636); 14355 _errHandler.sync(this); 14356 switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) { 14357 case 1: 14358 { 14359 setState(1635); 14360 match(CLASS_NAME); 14361 } 14362 break; 14363 } 14364 setState(1641); 14365 _errHandler.sync(this); 14366 _alt = getInterpreter().adaptivePredict(_input,141,_ctx); 14367 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14368 if ( _alt==1 ) { 14369 { 14370 { 14371 setState(1638); 14372 _la = _input.LA(1); 14373 if ( !(_la==WS || _la==NEWLINE) ) { 14374 _errHandler.recoverInline(this); 14375 } 14376 else { 14377 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14378 _errHandler.reportMatch(this); 14379 consume(); 14380 } 14381 } 14382 } 14383 } 14384 setState(1643); 14385 _errHandler.sync(this); 14386 _alt = getInterpreter().adaptivePredict(_input,141,_ctx); 14387 } 14388 setState(1645); 14389 _errHandler.sync(this); 14390 switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) { 14391 case 1: 14392 { 14393 setState(1644); 14394 description(); 14395 } 14396 break; 14397 } 14398 } 14399 break; 14400 case PARAM_LITERAL: 14401 enterOuterAlt(_localctx, 4); 14402 { 14403 setState(1647); 14404 match(PARAM_LITERAL); 14405 setState(1651); 14406 _errHandler.sync(this); 14407 _alt = getInterpreter().adaptivePredict(_input,143,_ctx); 14408 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14409 if ( _alt==1 ) { 14410 { 14411 { 14412 setState(1648); 14413 _la = _input.LA(1); 14414 if ( !(_la==WS || _la==NEWLINE) ) { 14415 _errHandler.recoverInline(this); 14416 } 14417 else { 14418 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14419 _errHandler.reportMatch(this); 14420 consume(); 14421 } 14422 } 14423 } 14424 } 14425 setState(1653); 14426 _errHandler.sync(this); 14427 _alt = getInterpreter().adaptivePredict(_input,143,_ctx); 14428 } 14429 setState(1655); 14430 _errHandler.sync(this); 14431 switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { 14432 case 1: 14433 { 14434 setState(1654); 14435 match(PARAMETER_NAME); 14436 } 14437 break; 14438 } 14439 setState(1660); 14440 _errHandler.sync(this); 14441 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 14442 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14443 if ( _alt==1 ) { 14444 { 14445 { 14446 setState(1657); 14447 _la = _input.LA(1); 14448 if ( !(_la==WS || _la==NEWLINE) ) { 14449 _errHandler.recoverInline(this); 14450 } 14451 else { 14452 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14453 _errHandler.reportMatch(this); 14454 consume(); 14455 } 14456 } 14457 } 14458 } 14459 setState(1662); 14460 _errHandler.sync(this); 14461 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 14462 } 14463 setState(1664); 14464 _errHandler.sync(this); 14465 switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { 14466 case 1: 14467 { 14468 setState(1663); 14469 description(); 14470 } 14471 break; 14472 } 14473 } 14474 break; 14475 case RETURN_LITERAL: 14476 enterOuterAlt(_localctx, 5); 14477 { 14478 setState(1666); 14479 match(RETURN_LITERAL); 14480 setState(1670); 14481 _errHandler.sync(this); 14482 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 14483 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14484 if ( _alt==1 ) { 14485 { 14486 { 14487 setState(1667); 14488 _la = _input.LA(1); 14489 if ( !(_la==WS || _la==NEWLINE) ) { 14490 _errHandler.recoverInline(this); 14491 } 14492 else { 14493 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14494 _errHandler.reportMatch(this); 14495 consume(); 14496 } 14497 } 14498 } 14499 } 14500 setState(1672); 14501 _errHandler.sync(this); 14502 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 14503 } 14504 setState(1674); 14505 _errHandler.sync(this); 14506 switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { 14507 case 1: 14508 { 14509 setState(1673); 14510 description(); 14511 } 14512 break; 14513 } 14514 } 14515 break; 14516 case SEE_LITERAL: 14517 enterOuterAlt(_localctx, 6); 14518 { 14519 setState(1676); 14520 match(SEE_LITERAL); 14521 setState(1680); 14522 _errHandler.sync(this); 14523 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 14524 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14525 if ( _alt==1 ) { 14526 { 14527 { 14528 setState(1677); 14529 _la = _input.LA(1); 14530 if ( !(_la==WS || _la==NEWLINE) ) { 14531 _errHandler.recoverInline(this); 14532 } 14533 else { 14534 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14535 _errHandler.reportMatch(this); 14536 consume(); 14537 } 14538 } 14539 } 14540 } 14541 setState(1682); 14542 _errHandler.sync(this); 14543 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 14544 } 14545 setState(1684); 14546 _errHandler.sync(this); 14547 switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { 14548 case 1: 14549 { 14550 setState(1683); 14551 reference(); 14552 } 14553 break; 14554 } 14555 setState(1690); 14556 _errHandler.sync(this); 14557 _alt = getInterpreter().adaptivePredict(_input,152,_ctx); 14558 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14559 if ( _alt==1 ) { 14560 { 14561 setState(1688); 14562 _errHandler.sync(this); 14563 switch (_input.LA(1)) { 14564 case STRING: 14565 { 14566 setState(1686); 14567 match(STRING); 14568 } 14569 break; 14570 case OPEN: 14571 { 14572 setState(1687); 14573 htmlElement(); 14574 } 14575 break; 14576 default: 14577 throw new NoViableAltException(this); 14578 } 14579 } 14580 } 14581 setState(1692); 14582 _errHandler.sync(this); 14583 _alt = getInterpreter().adaptivePredict(_input,152,_ctx); 14584 } 14585 setState(1696); 14586 _errHandler.sync(this); 14587 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 14588 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14589 if ( _alt==1 ) { 14590 { 14591 { 14592 setState(1693); 14593 _la = _input.LA(1); 14594 if ( !(_la==WS || _la==NEWLINE) ) { 14595 _errHandler.recoverInline(this); 14596 } 14597 else { 14598 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14599 _errHandler.reportMatch(this); 14600 consume(); 14601 } 14602 } 14603 } 14604 } 14605 setState(1698); 14606 _errHandler.sync(this); 14607 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 14608 } 14609 setState(1700); 14610 _errHandler.sync(this); 14611 switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { 14612 case 1: 14613 { 14614 setState(1699); 14615 description(); 14616 } 14617 break; 14618 } 14619 } 14620 break; 14621 case SERIAL_LITERAL: 14622 enterOuterAlt(_localctx, 7); 14623 { 14624 setState(1702); 14625 match(SERIAL_LITERAL); 14626 setState(1706); 14627 _errHandler.sync(this); 14628 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 14629 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14630 if ( _alt==1 ) { 14631 { 14632 { 14633 setState(1703); 14634 _la = _input.LA(1); 14635 if ( !(_la==WS || _la==NEWLINE) ) { 14636 _errHandler.recoverInline(this); 14637 } 14638 else { 14639 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14640 _errHandler.reportMatch(this); 14641 consume(); 14642 } 14643 } 14644 } 14645 } 14646 setState(1708); 14647 _errHandler.sync(this); 14648 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 14649 } 14650 setState(1710); 14651 _errHandler.sync(this); 14652 switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { 14653 case 1: 14654 { 14655 setState(1709); 14656 _la = _input.LA(1); 14657 if ( !(_la==LITERAL_INCLUDE || _la==LITERAL_EXCLUDE) ) { 14658 _errHandler.recoverInline(this); 14659 } 14660 else { 14661 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14662 _errHandler.reportMatch(this); 14663 consume(); 14664 } 14665 } 14666 break; 14667 } 14668 setState(1713); 14669 _errHandler.sync(this); 14670 switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { 14671 case 1: 14672 { 14673 setState(1712); 14674 description(); 14675 } 14676 break; 14677 } 14678 } 14679 break; 14680 case SERIAL_DATA_LITERAL: 14681 enterOuterAlt(_localctx, 8); 14682 { 14683 setState(1715); 14684 match(SERIAL_DATA_LITERAL); 14685 setState(1719); 14686 _errHandler.sync(this); 14687 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14688 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14689 if ( _alt==1 ) { 14690 { 14691 { 14692 setState(1716); 14693 _la = _input.LA(1); 14694 if ( !(_la==WS || _la==NEWLINE) ) { 14695 _errHandler.recoverInline(this); 14696 } 14697 else { 14698 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14699 _errHandler.reportMatch(this); 14700 consume(); 14701 } 14702 } 14703 } 14704 } 14705 setState(1721); 14706 _errHandler.sync(this); 14707 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14708 } 14709 setState(1723); 14710 _errHandler.sync(this); 14711 switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) { 14712 case 1: 14713 { 14714 setState(1722); 14715 description(); 14716 } 14717 break; 14718 } 14719 } 14720 break; 14721 case SERIAL_FIELD_LITERAL: 14722 enterOuterAlt(_localctx, 9); 14723 { 14724 setState(1725); 14725 match(SERIAL_FIELD_LITERAL); 14726 setState(1729); 14727 _errHandler.sync(this); 14728 _alt = getInterpreter().adaptivePredict(_input,160,_ctx); 14729 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14730 if ( _alt==1 ) { 14731 { 14732 { 14733 setState(1726); 14734 _la = _input.LA(1); 14735 if ( !(_la==WS || _la==NEWLINE) ) { 14736 _errHandler.recoverInline(this); 14737 } 14738 else { 14739 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14740 _errHandler.reportMatch(this); 14741 consume(); 14742 } 14743 } 14744 } 14745 } 14746 setState(1731); 14747 _errHandler.sync(this); 14748 _alt = getInterpreter().adaptivePredict(_input,160,_ctx); 14749 } 14750 setState(1733); 14751 _errHandler.sync(this); 14752 switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) { 14753 case 1: 14754 { 14755 setState(1732); 14756 match(FIELD_NAME); 14757 } 14758 break; 14759 } 14760 setState(1738); 14761 _errHandler.sync(this); 14762 _alt = getInterpreter().adaptivePredict(_input,162,_ctx); 14763 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14764 if ( _alt==1 ) { 14765 { 14766 { 14767 setState(1735); 14768 _la = _input.LA(1); 14769 if ( !(_la==WS || _la==NEWLINE) ) { 14770 _errHandler.recoverInline(this); 14771 } 14772 else { 14773 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14774 _errHandler.reportMatch(this); 14775 consume(); 14776 } 14777 } 14778 } 14779 } 14780 setState(1740); 14781 _errHandler.sync(this); 14782 _alt = getInterpreter().adaptivePredict(_input,162,_ctx); 14783 } 14784 setState(1742); 14785 _errHandler.sync(this); 14786 switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) { 14787 case 1: 14788 { 14789 setState(1741); 14790 match(FIELD_TYPE); 14791 } 14792 break; 14793 } 14794 setState(1747); 14795 _errHandler.sync(this); 14796 _alt = getInterpreter().adaptivePredict(_input,164,_ctx); 14797 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14798 if ( _alt==1 ) { 14799 { 14800 { 14801 setState(1744); 14802 _la = _input.LA(1); 14803 if ( !(_la==WS || _la==NEWLINE) ) { 14804 _errHandler.recoverInline(this); 14805 } 14806 else { 14807 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14808 _errHandler.reportMatch(this); 14809 consume(); 14810 } 14811 } 14812 } 14813 } 14814 setState(1749); 14815 _errHandler.sync(this); 14816 _alt = getInterpreter().adaptivePredict(_input,164,_ctx); 14817 } 14818 setState(1751); 14819 _errHandler.sync(this); 14820 switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) { 14821 case 1: 14822 { 14823 setState(1750); 14824 description(); 14825 } 14826 break; 14827 } 14828 } 14829 break; 14830 case SINCE_LITERAL: 14831 enterOuterAlt(_localctx, 10); 14832 { 14833 setState(1753); 14834 match(SINCE_LITERAL); 14835 setState(1757); 14836 _errHandler.sync(this); 14837 _alt = getInterpreter().adaptivePredict(_input,166,_ctx); 14838 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14839 if ( _alt==1 ) { 14840 { 14841 { 14842 setState(1754); 14843 _la = _input.LA(1); 14844 if ( !(_la==WS || _la==NEWLINE) ) { 14845 _errHandler.recoverInline(this); 14846 } 14847 else { 14848 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14849 _errHandler.reportMatch(this); 14850 consume(); 14851 } 14852 } 14853 } 14854 } 14855 setState(1759); 14856 _errHandler.sync(this); 14857 _alt = getInterpreter().adaptivePredict(_input,166,_ctx); 14858 } 14859 setState(1761); 14860 _errHandler.sync(this); 14861 switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { 14862 case 1: 14863 { 14864 setState(1760); 14865 description(); 14866 } 14867 break; 14868 } 14869 } 14870 break; 14871 case THROWS_LITERAL: 14872 enterOuterAlt(_localctx, 11); 14873 { 14874 setState(1763); 14875 match(THROWS_LITERAL); 14876 setState(1767); 14877 _errHandler.sync(this); 14878 _alt = getInterpreter().adaptivePredict(_input,168,_ctx); 14879 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14880 if ( _alt==1 ) { 14881 { 14882 { 14883 setState(1764); 14884 _la = _input.LA(1); 14885 if ( !(_la==WS || _la==NEWLINE) ) { 14886 _errHandler.recoverInline(this); 14887 } 14888 else { 14889 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14890 _errHandler.reportMatch(this); 14891 consume(); 14892 } 14893 } 14894 } 14895 } 14896 setState(1769); 14897 _errHandler.sync(this); 14898 _alt = getInterpreter().adaptivePredict(_input,168,_ctx); 14899 } 14900 setState(1771); 14901 _errHandler.sync(this); 14902 switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) { 14903 case 1: 14904 { 14905 setState(1770); 14906 match(CLASS_NAME); 14907 } 14908 break; 14909 } 14910 setState(1776); 14911 _errHandler.sync(this); 14912 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14913 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14914 if ( _alt==1 ) { 14915 { 14916 { 14917 setState(1773); 14918 _la = _input.LA(1); 14919 if ( !(_la==WS || _la==NEWLINE) ) { 14920 _errHandler.recoverInline(this); 14921 } 14922 else { 14923 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14924 _errHandler.reportMatch(this); 14925 consume(); 14926 } 14927 } 14928 } 14929 } 14930 setState(1778); 14931 _errHandler.sync(this); 14932 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14933 } 14934 setState(1780); 14935 _errHandler.sync(this); 14936 switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) { 14937 case 1: 14938 { 14939 setState(1779); 14940 description(); 14941 } 14942 break; 14943 } 14944 } 14945 break; 14946 case VERSION_LITERAL: 14947 enterOuterAlt(_localctx, 12); 14948 { 14949 setState(1782); 14950 match(VERSION_LITERAL); 14951 setState(1786); 14952 _errHandler.sync(this); 14953 _alt = getInterpreter().adaptivePredict(_input,172,_ctx); 14954 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14955 if ( _alt==1 ) { 14956 { 14957 { 14958 setState(1783); 14959 _la = _input.LA(1); 14960 if ( !(_la==WS || _la==NEWLINE) ) { 14961 _errHandler.recoverInline(this); 14962 } 14963 else { 14964 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 14965 _errHandler.reportMatch(this); 14966 consume(); 14967 } 14968 } 14969 } 14970 } 14971 setState(1788); 14972 _errHandler.sync(this); 14973 _alt = getInterpreter().adaptivePredict(_input,172,_ctx); 14974 } 14975 setState(1790); 14976 _errHandler.sync(this); 14977 switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) { 14978 case 1: 14979 { 14980 setState(1789); 14981 description(); 14982 } 14983 break; 14984 } 14985 } 14986 break; 14987 case CUSTOM_NAME: 14988 enterOuterAlt(_localctx, 13); 14989 { 14990 setState(1792); 14991 match(CUSTOM_NAME); 14992 setState(1796); 14993 _errHandler.sync(this); 14994 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 14995 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14996 if ( _alt==1 ) { 14997 { 14998 { 14999 setState(1793); 15000 _la = _input.LA(1); 15001 if ( !(_la==WS || _la==NEWLINE) ) { 15002 _errHandler.recoverInline(this); 15003 } 15004 else { 15005 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15006 _errHandler.reportMatch(this); 15007 consume(); 15008 } 15009 } 15010 } 15011 } 15012 setState(1798); 15013 _errHandler.sync(this); 15014 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 15015 } 15016 setState(1800); 15017 _errHandler.sync(this); 15018 switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) { 15019 case 1: 15020 { 15021 setState(1799); 15022 description(); 15023 } 15024 break; 15025 } 15026 } 15027 break; 15028 default: 15029 throw new NoViableAltException(this); 15030 } 15031 } 15032 catch (RecognitionException re) { 15033 _localctx.exception = re; 15034 _errHandler.reportError(this, re); 15035 _errHandler.recover(this, re); 15036 } 15037 finally { 15038 exitRule(); 15039 } 15040 return _localctx; 15041 } 15042 15043 public static class JavadocInlineTagContext extends ParserRuleContext { 15044 public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); } 15045 public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); } 15046 public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); } 15047 public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); } 15048 public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); } 15049 public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); } 15050 public ReferenceContext reference() { 15051 return getRuleContext(ReferenceContext.class,0); 15052 } 15053 public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); } 15054 public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); } 15055 public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); } 15056 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 15057 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15058 public TerminalNode WS(int i) { 15059 return getToken(JavadocParser.WS, i); 15060 } 15061 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15062 public TerminalNode NEWLINE(int i) { 15063 return getToken(JavadocParser.NEWLINE, i); 15064 } 15065 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15066 public TerminalNode LEADING_ASTERISK(int i) { 15067 return getToken(JavadocParser.LEADING_ASTERISK, i); 15068 } 15069 public List<TextContext> text() { 15070 return getRuleContexts(TextContext.class); 15071 } 15072 public TextContext text(int i) { 15073 return getRuleContext(TextContext.class,i); 15074 } 15075 public DescriptionContext description() { 15076 return getRuleContext(DescriptionContext.class,0); 15077 } 15078 public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) { 15079 super(parent, invokingState); 15080 } 15081 @Override public int getRuleIndex() { return RULE_javadocInlineTag; } 15082 @Override 15083 public void enterRule(ParseTreeListener listener) { 15084 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocInlineTag(this); 15085 } 15086 @Override 15087 public void exitRule(ParseTreeListener listener) { 15088 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocInlineTag(this); 15089 } 15090 @Override 15091 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15092 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocInlineTag(this); 15093 else return visitor.visitChildren(this); 15094 } 15095 } 15096 15097 public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException { 15098 JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState()); 15099 enterRule(_localctx, 144, RULE_javadocInlineTag); 15100 int _la; 15101 try { 15102 int _alt; 15103 enterOuterAlt(_localctx, 1); 15104 { 15105 setState(1804); 15106 match(JAVADOC_INLINE_TAG_START); 15107 setState(1881); 15108 _errHandler.sync(this); 15109 switch (_input.LA(1)) { 15110 case CODE_LITERAL: 15111 { 15112 setState(1805); 15113 match(CODE_LITERAL); 15114 setState(1812); 15115 _errHandler.sync(this); 15116 _la = _input.LA(1); 15117 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15118 { 15119 setState(1810); 15120 _errHandler.sync(this); 15121 switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) { 15122 case 1: 15123 { 15124 setState(1806); 15125 match(WS); 15126 } 15127 break; 15128 case 2: 15129 { 15130 setState(1807); 15131 match(NEWLINE); 15132 } 15133 break; 15134 case 3: 15135 { 15136 setState(1808); 15137 match(LEADING_ASTERISK); 15138 } 15139 break; 15140 case 4: 15141 { 15142 setState(1809); 15143 text(); 15144 } 15145 break; 15146 } 15147 } 15148 setState(1814); 15149 _errHandler.sync(this); 15150 _la = _input.LA(1); 15151 } 15152 } 15153 break; 15154 case DOC_ROOT_LITERAL: 15155 { 15156 setState(1815); 15157 match(DOC_ROOT_LITERAL); 15158 setState(1819); 15159 _errHandler.sync(this); 15160 _la = _input.LA(1); 15161 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15162 { 15163 { 15164 setState(1816); 15165 _la = _input.LA(1); 15166 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15167 _errHandler.recoverInline(this); 15168 } 15169 else { 15170 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15171 _errHandler.reportMatch(this); 15172 consume(); 15173 } 15174 } 15175 } 15176 setState(1821); 15177 _errHandler.sync(this); 15178 _la = _input.LA(1); 15179 } 15180 } 15181 break; 15182 case INHERIT_DOC_LITERAL: 15183 { 15184 setState(1822); 15185 match(INHERIT_DOC_LITERAL); 15186 setState(1826); 15187 _errHandler.sync(this); 15188 _la = _input.LA(1); 15189 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15190 { 15191 { 15192 setState(1823); 15193 _la = _input.LA(1); 15194 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15195 _errHandler.recoverInline(this); 15196 } 15197 else { 15198 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15199 _errHandler.reportMatch(this); 15200 consume(); 15201 } 15202 } 15203 } 15204 setState(1828); 15205 _errHandler.sync(this); 15206 _la = _input.LA(1); 15207 } 15208 } 15209 break; 15210 case LINK_LITERAL: 15211 { 15212 setState(1829); 15213 match(LINK_LITERAL); 15214 setState(1833); 15215 _errHandler.sync(this); 15216 _la = _input.LA(1); 15217 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15218 { 15219 { 15220 setState(1830); 15221 _la = _input.LA(1); 15222 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15223 _errHandler.recoverInline(this); 15224 } 15225 else { 15226 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15227 _errHandler.reportMatch(this); 15228 consume(); 15229 } 15230 } 15231 } 15232 setState(1835); 15233 _errHandler.sync(this); 15234 _la = _input.LA(1); 15235 } 15236 setState(1836); 15237 reference(); 15238 setState(1838); 15239 _errHandler.sync(this); 15240 switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { 15241 case 1: 15242 { 15243 setState(1837); 15244 description(); 15245 } 15246 break; 15247 } 15248 } 15249 break; 15250 case LINKPLAIN_LITERAL: 15251 { 15252 setState(1840); 15253 match(LINKPLAIN_LITERAL); 15254 setState(1844); 15255 _errHandler.sync(this); 15256 _la = _input.LA(1); 15257 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15258 { 15259 { 15260 setState(1841); 15261 _la = _input.LA(1); 15262 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15263 _errHandler.recoverInline(this); 15264 } 15265 else { 15266 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15267 _errHandler.reportMatch(this); 15268 consume(); 15269 } 15270 } 15271 } 15272 setState(1846); 15273 _errHandler.sync(this); 15274 _la = _input.LA(1); 15275 } 15276 setState(1847); 15277 reference(); 15278 setState(1849); 15279 _errHandler.sync(this); 15280 switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) { 15281 case 1: 15282 { 15283 setState(1848); 15284 description(); 15285 } 15286 break; 15287 } 15288 } 15289 break; 15290 case LITERAL_LITERAL: 15291 { 15292 setState(1851); 15293 match(LITERAL_LITERAL); 15294 setState(1858); 15295 _errHandler.sync(this); 15296 _la = _input.LA(1); 15297 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15298 { 15299 setState(1856); 15300 _errHandler.sync(this); 15301 switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) { 15302 case 1: 15303 { 15304 setState(1852); 15305 match(WS); 15306 } 15307 break; 15308 case 2: 15309 { 15310 setState(1853); 15311 match(NEWLINE); 15312 } 15313 break; 15314 case 3: 15315 { 15316 setState(1854); 15317 match(LEADING_ASTERISK); 15318 } 15319 break; 15320 case 4: 15321 { 15322 setState(1855); 15323 text(); 15324 } 15325 break; 15326 } 15327 } 15328 setState(1860); 15329 _errHandler.sync(this); 15330 _la = _input.LA(1); 15331 } 15332 } 15333 break; 15334 case VALUE_LITERAL: 15335 { 15336 setState(1861); 15337 match(VALUE_LITERAL); 15338 setState(1865); 15339 _errHandler.sync(this); 15340 _la = _input.LA(1); 15341 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15342 { 15343 { 15344 setState(1862); 15345 _la = _input.LA(1); 15346 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15347 _errHandler.recoverInline(this); 15348 } 15349 else { 15350 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15351 _errHandler.reportMatch(this); 15352 consume(); 15353 } 15354 } 15355 } 15356 setState(1867); 15357 _errHandler.sync(this); 15358 _la = _input.LA(1); 15359 } 15360 setState(1869); 15361 _errHandler.sync(this); 15362 _la = _input.LA(1); 15363 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << DOT) | (1L << HASH) | (1L << CLASS) | (1L << MEMBER))) != 0)) { 15364 { 15365 setState(1868); 15366 reference(); 15367 } 15368 } 15369 15370 } 15371 break; 15372 case CUSTOM_NAME: 15373 { 15374 setState(1871); 15375 match(CUSTOM_NAME); 15376 setState(1875); 15377 _errHandler.sync(this); 15378 _alt = getInterpreter().adaptivePredict(_input,189,_ctx); 15379 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15380 if ( _alt==1 ) { 15381 { 15382 { 15383 setState(1872); 15384 _la = _input.LA(1); 15385 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15386 _errHandler.recoverInline(this); 15387 } 15388 else { 15389 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15390 _errHandler.reportMatch(this); 15391 consume(); 15392 } 15393 } 15394 } 15395 } 15396 setState(1877); 15397 _errHandler.sync(this); 15398 _alt = getInterpreter().adaptivePredict(_input,189,_ctx); 15399 } 15400 setState(1879); 15401 _errHandler.sync(this); 15402 switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) { 15403 case 1: 15404 { 15405 setState(1878); 15406 description(); 15407 } 15408 break; 15409 } 15410 } 15411 break; 15412 default: 15413 throw new NoViableAltException(this); 15414 } 15415 setState(1883); 15416 match(JAVADOC_INLINE_TAG_END); 15417 } 15418 } 15419 catch (RecognitionException re) { 15420 _localctx.exception = re; 15421 _errHandler.reportError(this, re); 15422 _errHandler.recover(this, re); 15423 } 15424 finally { 15425 exitRule(); 15426 } 15427 return _localctx; 15428 } 15429 15430 public static class HtmlCommentContext extends ParserRuleContext { 15431 public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); } 15432 public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); } 15433 public List<TextContext> text() { 15434 return getRuleContexts(TextContext.class); 15435 } 15436 public TextContext text(int i) { 15437 return getRuleContext(TextContext.class,i); 15438 } 15439 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15440 public TerminalNode NEWLINE(int i) { 15441 return getToken(JavadocParser.NEWLINE, i); 15442 } 15443 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15444 public TerminalNode LEADING_ASTERISK(int i) { 15445 return getToken(JavadocParser.LEADING_ASTERISK, i); 15446 } 15447 public HtmlCommentContext(ParserRuleContext parent, int invokingState) { 15448 super(parent, invokingState); 15449 } 15450 @Override public int getRuleIndex() { return RULE_htmlComment; } 15451 @Override 15452 public void enterRule(ParseTreeListener listener) { 15453 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlComment(this); 15454 } 15455 @Override 15456 public void exitRule(ParseTreeListener listener) { 15457 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlComment(this); 15458 } 15459 @Override 15460 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15461 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlComment(this); 15462 else return visitor.visitChildren(this); 15463 } 15464 } 15465 15466 public final HtmlCommentContext htmlComment() throws RecognitionException { 15467 HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState()); 15468 enterRule(_localctx, 146, RULE_htmlComment); 15469 int _la; 15470 try { 15471 enterOuterAlt(_localctx, 1); 15472 { 15473 setState(1885); 15474 match(HTML_COMMENT_START); 15475 setState(1891); 15476 _errHandler.sync(this); 15477 _la = _input.LA(1); 15478 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15479 { 15480 setState(1889); 15481 _errHandler.sync(this); 15482 switch (_input.LA(1)) { 15483 case WS: 15484 case CHAR: 15485 { 15486 setState(1886); 15487 text(); 15488 } 15489 break; 15490 case NEWLINE: 15491 { 15492 setState(1887); 15493 match(NEWLINE); 15494 } 15495 break; 15496 case LEADING_ASTERISK: 15497 { 15498 setState(1888); 15499 match(LEADING_ASTERISK); 15500 } 15501 break; 15502 default: 15503 throw new NoViableAltException(this); 15504 } 15505 } 15506 setState(1893); 15507 _errHandler.sync(this); 15508 _la = _input.LA(1); 15509 } 15510 setState(1894); 15511 match(HTML_COMMENT_END); 15512 } 15513 } 15514 catch (RecognitionException re) { 15515 _localctx.exception = re; 15516 _errHandler.reportError(this, re); 15517 _errHandler.recover(this, re); 15518 } 15519 finally { 15520 exitRule(); 15521 } 15522 return _localctx; 15523 } 15524 15525 public static class TextContext extends ParserRuleContext { 15526 public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); } 15527 public TerminalNode CHAR(int i) { 15528 return getToken(JavadocParser.CHAR, i); 15529 } 15530 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15531 public TerminalNode WS(int i) { 15532 return getToken(JavadocParser.WS, i); 15533 } 15534 public TextContext(ParserRuleContext parent, int invokingState) { 15535 super(parent, invokingState); 15536 } 15537 @Override public int getRuleIndex() { return RULE_text; } 15538 @Override 15539 public void enterRule(ParseTreeListener listener) { 15540 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterText(this); 15541 } 15542 @Override 15543 public void exitRule(ParseTreeListener listener) { 15544 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitText(this); 15545 } 15546 @Override 15547 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15548 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitText(this); 15549 else return visitor.visitChildren(this); 15550 } 15551 } 15552 15553 public final TextContext text() throws RecognitionException { 15554 TextContext _localctx = new TextContext(_ctx, getState()); 15555 enterRule(_localctx, 148, RULE_text); 15556 int _la; 15557 try { 15558 int _alt; 15559 enterOuterAlt(_localctx, 1); 15560 { 15561 setState(1898); 15562 _errHandler.sync(this); 15563 _alt = 1; 15564 do { 15565 switch (_alt) { 15566 case 1: 15567 { 15568 { 15569 setState(1896); 15570 _la = _input.LA(1); 15571 if ( !(_la==WS || _la==CHAR) ) { 15572 _errHandler.recoverInline(this); 15573 } 15574 else { 15575 if ( _input.LA(1)==Token.EOF ) matchedEOF = true; 15576 _errHandler.reportMatch(this); 15577 consume(); 15578 } 15579 15580 _la = _input.LA(1); 15581 if ((_la != WS) && (_la != CHAR)) return _localctx; 15582 else if (_alt == 1) continue; 15583 15584 } 15585 } 15586 break; 15587 default: 15588 throw new NoViableAltException(this); 15589 } 15590 setState(1900); 15591 _errHandler.sync(this); 15592 _alt = getInterpreter().adaptivePredict(_input,194,_ctx); 15593 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15594 } 15595 } 15596 catch (RecognitionException re) { 15597 _localctx.exception = re; 15598 _errHandler.reportError(this, re); 15599 _errHandler.recover(this, re); 15600 } 15601 finally { 15602 exitRule(); 15603 } 15604 return _localctx; 15605 } 15606 15607 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { 15608 switch (ruleIndex) { 15609 case 0: 15610 return javadoc_sempred((JavadocContext)_localctx, predIndex); 15611 case 5: 15612 return htmlTag_sempred((HtmlTagContext)_localctx, predIndex); 15613 case 8: 15614 return paragraph_sempred((ParagraphContext)_localctx, predIndex); 15615 case 11: 15616 return li_sempred((LiContext)_localctx, predIndex); 15617 case 14: 15618 return tr_sempred((TrContext)_localctx, predIndex); 15619 case 17: 15620 return td_sempred((TdContext)_localctx, predIndex); 15621 case 20: 15622 return th_sempred((ThContext)_localctx, predIndex); 15623 case 23: 15624 return body_sempred((BodyContext)_localctx, predIndex); 15625 case 26: 15626 return colgroup_sempred((ColgroupContext)_localctx, predIndex); 15627 case 29: 15628 return dd_sempred((DdContext)_localctx, predIndex); 15629 case 32: 15630 return dt_sempred((DtContext)_localctx, predIndex); 15631 case 35: 15632 return head_sempred((HeadContext)_localctx, predIndex); 15633 case 38: 15634 return html_sempred((HtmlContext)_localctx, predIndex); 15635 case 41: 15636 return option_sempred((OptionContext)_localctx, predIndex); 15637 case 44: 15638 return tbody_sempred((TbodyContext)_localctx, predIndex); 15639 case 47: 15640 return tfoot_sempred((TfootContext)_localctx, predIndex); 15641 case 50: 15642 return thead_sempred((TheadContext)_localctx, predIndex); 15643 case 68: 15644 return description_sempred((DescriptionContext)_localctx, predIndex); 15645 } 15646 return true; 15647 } 15648 private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) { 15649 switch (predIndex) { 15650 case 0: 15651 return !isNextJavadocTag(); 15652 } 15653 return true; 15654 } 15655 private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) { 15656 switch (predIndex) { 15657 case 1: 15658 return !isNextJavadocTag(); 15659 case 2: 15660 return !isNextJavadocTag(); 15661 } 15662 return true; 15663 } 15664 private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) { 15665 switch (predIndex) { 15666 case 3: 15667 return !isNextJavadocTag(); 15668 } 15669 return true; 15670 } 15671 private boolean li_sempred(LiContext _localctx, int predIndex) { 15672 switch (predIndex) { 15673 case 4: 15674 return !isNextJavadocTag(); 15675 } 15676 return true; 15677 } 15678 private boolean tr_sempred(TrContext _localctx, int predIndex) { 15679 switch (predIndex) { 15680 case 5: 15681 return !isNextJavadocTag(); 15682 } 15683 return true; 15684 } 15685 private boolean td_sempred(TdContext _localctx, int predIndex) { 15686 switch (predIndex) { 15687 case 6: 15688 return !isNextJavadocTag(); 15689 } 15690 return true; 15691 } 15692 private boolean th_sempred(ThContext _localctx, int predIndex) { 15693 switch (predIndex) { 15694 case 7: 15695 return !isNextJavadocTag(); 15696 } 15697 return true; 15698 } 15699 private boolean body_sempred(BodyContext _localctx, int predIndex) { 15700 switch (predIndex) { 15701 case 8: 15702 return !isNextJavadocTag(); 15703 } 15704 return true; 15705 } 15706 private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) { 15707 switch (predIndex) { 15708 case 9: 15709 return !isNextJavadocTag(); 15710 } 15711 return true; 15712 } 15713 private boolean dd_sempred(DdContext _localctx, int predIndex) { 15714 switch (predIndex) { 15715 case 10: 15716 return !isNextJavadocTag(); 15717 } 15718 return true; 15719 } 15720 private boolean dt_sempred(DtContext _localctx, int predIndex) { 15721 switch (predIndex) { 15722 case 11: 15723 return !isNextJavadocTag(); 15724 } 15725 return true; 15726 } 15727 private boolean head_sempred(HeadContext _localctx, int predIndex) { 15728 switch (predIndex) { 15729 case 12: 15730 return !isNextJavadocTag(); 15731 } 15732 return true; 15733 } 15734 private boolean html_sempred(HtmlContext _localctx, int predIndex) { 15735 switch (predIndex) { 15736 case 13: 15737 return !isNextJavadocTag(); 15738 } 15739 return true; 15740 } 15741 private boolean option_sempred(OptionContext _localctx, int predIndex) { 15742 switch (predIndex) { 15743 case 14: 15744 return !isNextJavadocTag(); 15745 } 15746 return true; 15747 } 15748 private boolean tbody_sempred(TbodyContext _localctx, int predIndex) { 15749 switch (predIndex) { 15750 case 15: 15751 return !isNextJavadocTag(); 15752 } 15753 return true; 15754 } 15755 private boolean tfoot_sempred(TfootContext _localctx, int predIndex) { 15756 switch (predIndex) { 15757 case 16: 15758 return !isNextJavadocTag(); 15759 } 15760 return true; 15761 } 15762 private boolean thead_sempred(TheadContext _localctx, int predIndex) { 15763 switch (predIndex) { 15764 case 17: 15765 return !isNextJavadocTag(); 15766 } 15767 return true; 15768 } 15769 private boolean description_sempred(DescriptionContext _localctx, int predIndex) { 15770 switch (predIndex) { 15771 case 18: 15772 return !isNextJavadocTag(); 15773 } 15774 return true; 15775 } 15776 15777 public static final String _serializedATN = 15778 "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3]\u0771\4\2\t\2\4"+ 15779 "\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"+ 15780 "\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"+ 15781 "\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"+ 15782 "\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!"+ 15783 "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ 15784 ",\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"+ 15785 "\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="+ 15786 "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ 15787 "\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"+ 15788 "\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"+ 15789 "\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"+ 15790 "\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"+ 15791 "\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"+ 15792 "\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"+ 15793 "\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"+ 15794 "\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"+ 15795 "\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"+ 15796 "\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"+ 15797 "\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"+ 15798 "\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"+ 15799 "\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"+ 15800 "\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"+ 15801 "\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"+ 15802 "\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"+ 15803 "\13\3\13\3\13\3\13\3\13\3\13\7\13\u0180\n\13\f\13\16\13\u0183\13\13\3"+ 15804 "\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"+ 15805 "\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"+ 15806 "\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"+ 15807 "\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"+ 15808 "\3\16\3\16\7\16\u01c5\n\16\f\16\16\16\u01c8\13\16\3\16\3\16\3\17\3\17"+ 15809 "\3\17\3\17\7\17\u01d0\n\17\f\17\16\17\u01d3\13\17\3\17\3\17\3\20\3\20"+ 15810 "\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"+ 15811 "\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"+ 15812 "\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"+ 15813 "\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"+ 15814 "\21\u020d\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0215\n\22\f\22\16"+ 15815 "\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"+ 15816 "\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"+ 15817 "\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"+ 15818 "\3\23\7\23\u0242\n\23\f\23\16\23\u0245\13\23\3\23\3\23\3\24\3\24\3\24"+ 15819 "\3\24\3\24\3\24\7\24\u024f\n\24\f\24\16\24\u0252\13\24\3\24\3\24\3\25"+ 15820 "\3\25\3\25\3\25\7\25\u025a\n\25\f\25\16\25\u025d\13\25\3\25\3\25\3\26"+ 15821 "\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"+ 15822 "\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"+ 15823 "\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"+ 15824 "\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"+ 15825 "\f\27\16\27\u0297\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u029f\n\30"+ 15826 "\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"+ 15827 "\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"+ 15828 "\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"+ 15829 "\31\3\31\3\31\7\31\u02cc\n\31\f\31\16\31\u02cf\13\31\3\31\3\31\3\32\3"+ 15830 "\32\3\32\3\32\3\32\3\32\7\32\u02d9\n\32\f\32\16\32\u02dc\13\32\3\32\3"+ 15831 "\32\3\33\3\33\3\33\3\33\7\33\u02e4\n\33\f\33\16\33\u02e7\13\33\3\33\3"+ 15832 "\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"+ 15833 "\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"+ 15834 "\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"+ 15835 "\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"+ 15836 "\n\35\f\35\16\35\u0321\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0329"+ 15837 "\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"+ 15838 "\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"+ 15839 "\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"+ 15840 "\37\3\37\3\37\3\37\7\37\u0356\n\37\f\37\16\37\u0359\13\37\3\37\3\37\3"+ 15841 " \3 \3 \3 \3 \3 \7 \u0363\n \f \16 \u0366\13 \3 \3 \3!\3!\3!\3!\7!\u036e"+ 15842 "\n!\f!\16!\u0371\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+ 15843 "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+ 15844 "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u039b\n\"\f\"\16\"\u039e\13"+ 15845 "\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u03a8\n#\f#\16#\u03ab\13#\3#\3#\3$\3$"+ 15846 "\3$\3$\7$\u03b3\n$\f$\16$\u03b6\13$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 15847 "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 15848 "%\3%\3%\3%\3%\3%\7%\u03e0\n%\f%\16%\u03e3\13%\3%\3%\3&\3&\3&\3&\3&\3&"+ 15849 "\7&\u03ed\n&\f&\16&\u03f0\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u03f8\n\'\f\'"+ 15850 "\16\'\u03fb\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+ 15851 "\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+ 15852 "\7(\u0425\n(\f(\16(\u0428\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u0432\n)\f)\16"+ 15853 ")\u0435\13)\3)\3)\3*\3*\3*\3*\7*\u043d\n*\f*\16*\u0440\13*\3*\3*\3+\3"+ 15854 "+\3+\3+\3+\3+\3+\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+\3+\3+\3+\3+\7+\u046a\n+\f+\16+\u046d\13+"+ 15856 "\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0477\n,\f,\16,\u047a\13,\3,\3,\3-\3-\3-\3"+ 15857 "-\7-\u0482\n-\f-\16-\u0485\13-\3-\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.\7.\u04af\n.\f.\16.\u04b2\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u04bc"+ 15860 "\n/\f/\16/\u04bf\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u04c7\n\60\f\60\16"+ 15861 "\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"+ 15862 "\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"+ 15863 "\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"+ 15864 "\3\61\7\61\u04f4\n\61\f\61\16\61\u04f7\13\61\3\61\3\61\3\62\3\62\3\62"+ 15865 "\3\62\3\62\3\62\7\62\u0501\n\62\f\62\16\62\u0504\13\62\3\62\3\62\3\63"+ 15866 "\3\63\3\63\3\63\7\63\u050c\n\63\f\63\16\63\u050f\13\63\3\63\3\63\3\64"+ 15867 "\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"+ 15868 "\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"+ 15869 "\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"+ 15870 "\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"+ 15871 "\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"+ 15872 "\3\66\7\66\u0557\n\66\f\66\16\66\u055a\13\66\3\66\3\66\3\67\3\67\3\67"+ 15873 "\3\67\3\67\3\67\7\67\u0564\n\67\f\67\16\67\u0567\13\67\3\67\3\67\38\3"+ 15874 "8\38\38\38\38\78\u0571\n8\f8\168\u0574\138\38\38\39\39\39\39\39\39\79"+ 15875 "\u057e\n9\f9\169\u0581\139\39\39\3:\3:\3:\3:\3:\3:\7:\u058b\n:\f:\16:"+ 15876 "\u058e\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0598\n;\f;\16;\u059b\13;\3;\3;"+ 15877 "\3<\3<\3<\3<\3<\3<\7<\u05a5\n<\f<\16<\u05a8\13<\3<\3<\3=\3=\3=\3=\3=\3"+ 15878 "=\7=\u05b2\n=\f=\16=\u05b5\13=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u05bf\n>\f>"+ 15879 "\16>\u05c2\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u05cc\n?\f?\16?\u05cf\13?\3"+ 15880 "?\3?\3@\3@\3@\3@\3@\3@\7@\u05d9\n@\f@\16@\u05dc\13@\3@\3@\3A\3A\3A\3A"+ 15881 "\3A\3A\7A\u05e6\nA\fA\16A\u05e9\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u05f3\n"+ 15882 "B\fB\16B\u05f6\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u0600\nC\fC\16C\u0603\13"+ 15883 "C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u0617\nF\r"+ 15884 "F\16F\u0618\3G\3G\7G\u061d\nG\fG\16G\u0620\13G\3G\5G\u0623\nG\3G\5G\u0626"+ 15885 "\nG\3G\5G\u0629\nG\3G\6G\u062c\nG\rG\16G\u062d\3G\5G\u0631\nG\3G\5G\u0634"+ 15886 "\nG\3G\5G\u0637\nG\3G\5G\u063a\nG\3G\3G\5G\u063e\nG\5G\u0640\nG\3H\3H"+ 15887 "\7H\u0644\nH\fH\16H\u0647\13H\3H\3H\3I\3I\7I\u064d\nI\fI\16I\u0650\13"+ 15888 "I\3I\5I\u0653\nI\3I\3I\7I\u0657\nI\fI\16I\u065a\13I\3I\5I\u065d\nI\3I"+ 15889 "\3I\7I\u0661\nI\fI\16I\u0664\13I\3I\5I\u0667\nI\3I\7I\u066a\nI\fI\16I"+ 15890 "\u066d\13I\3I\5I\u0670\nI\3I\3I\7I\u0674\nI\fI\16I\u0677\13I\3I\5I\u067a"+ 15891 "\nI\3I\7I\u067d\nI\fI\16I\u0680\13I\3I\5I\u0683\nI\3I\3I\7I\u0687\nI\f"+ 15892 "I\16I\u068a\13I\3I\5I\u068d\nI\3I\3I\7I\u0691\nI\fI\16I\u0694\13I\3I\5"+ 15893 "I\u0697\nI\3I\3I\7I\u069b\nI\fI\16I\u069e\13I\3I\7I\u06a1\nI\fI\16I\u06a4"+ 15894 "\13I\3I\5I\u06a7\nI\3I\3I\7I\u06ab\nI\fI\16I\u06ae\13I\3I\5I\u06b1\nI"+ 15895 "\3I\5I\u06b4\nI\3I\3I\7I\u06b8\nI\fI\16I\u06bb\13I\3I\5I\u06be\nI\3I\3"+ 15896 "I\7I\u06c2\nI\fI\16I\u06c5\13I\3I\5I\u06c8\nI\3I\7I\u06cb\nI\fI\16I\u06ce"+ 15897 "\13I\3I\5I\u06d1\nI\3I\7I\u06d4\nI\fI\16I\u06d7\13I\3I\5I\u06da\nI\3I"+ 15898 "\3I\7I\u06de\nI\fI\16I\u06e1\13I\3I\5I\u06e4\nI\3I\3I\7I\u06e8\nI\fI\16"+ 15899 "I\u06eb\13I\3I\5I\u06ee\nI\3I\7I\u06f1\nI\fI\16I\u06f4\13I\3I\5I\u06f7"+ 15900 "\nI\3I\3I\7I\u06fb\nI\fI\16I\u06fe\13I\3I\5I\u0701\nI\3I\3I\7I\u0705\n"+ 15901 "I\fI\16I\u0708\13I\3I\5I\u070b\nI\5I\u070d\nI\3J\3J\3J\3J\3J\3J\7J\u0715"+ 15902 "\nJ\fJ\16J\u0718\13J\3J\3J\7J\u071c\nJ\fJ\16J\u071f\13J\3J\3J\7J\u0723"+ 15903 "\nJ\fJ\16J\u0726\13J\3J\3J\7J\u072a\nJ\fJ\16J\u072d\13J\3J\3J\5J\u0731"+ 15904 "\nJ\3J\3J\7J\u0735\nJ\fJ\16J\u0738\13J\3J\3J\5J\u073c\nJ\3J\3J\3J\3J\3"+ 15905 "J\7J\u0743\nJ\fJ\16J\u0746\13J\3J\3J\7J\u074a\nJ\fJ\16J\u074d\13J\3J\5"+ 15906 "J\u0750\nJ\3J\3J\7J\u0754\nJ\fJ\16J\u0757\13J\3J\5J\u075a\nJ\5J\u075c"+ 15907 "\nJ\3J\3J\3K\3K\3K\3K\7K\u0764\nK\fK\16K\u0767\13K\3K\3K\3L\3L\6L\u076d"+ 15908 "\nL\rL\16L\u076e\3L\2\2M\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&("+ 15909 "*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084"+ 15910 "\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\2\13\5\2\3\3\6"+ 15911 "\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"+ 15912 "\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"+ 15913 "\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"+ 15914 "\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"+ 15915 "\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"+ 15916 " \u0203\3\2\2\2\"\u0210\3\2\2\2$\u021b\3\2\2\2&\u0248\3\2\2\2(\u0255\3"+ 15917 "\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"+ 15918 "\u02d2\3\2\2\2\64\u02df\3\2\2\2\66\u02ea\3\2\2\28\u0317\3\2\2\2:\u0324"+ 15919 "\3\2\2\2<\u032f\3\2\2\2>\u035c\3\2\2\2@\u0369\3\2\2\2B\u0374\3\2\2\2D"+ 15920 "\u03a1\3\2\2\2F\u03ae\3\2\2\2H\u03b9\3\2\2\2J\u03e6\3\2\2\2L\u03f3\3\2"+ 15921 "\2\2N\u03fe\3\2\2\2P\u042b\3\2\2\2R\u0438\3\2\2\2T\u0443\3\2\2\2V\u0470"+ 15922 "\3\2\2\2X\u047d\3\2\2\2Z\u0488\3\2\2\2\\\u04b5\3\2\2\2^\u04c2\3\2\2\2"+ 15923 "`\u04cd\3\2\2\2b\u04fa\3\2\2\2d\u0507\3\2\2\2f\u0512\3\2\2\2h\u054e\3"+ 15924 "\2\2\2j\u0550\3\2\2\2l\u055d\3\2\2\2n\u056a\3\2\2\2p\u0577\3\2\2\2r\u0584"+ 15925 "\3\2\2\2t\u0591\3\2\2\2v\u059e\3\2\2\2x\u05ab\3\2\2\2z\u05b8\3\2\2\2|"+ 15926 "\u05c5\3\2\2\2~\u05d2\3\2\2\2\u0080\u05df\3\2\2\2\u0082\u05ec\3\2\2\2"+ 15927 "\u0084\u05f9\3\2\2\2\u0086\u0606\3\2\2\2\u0088\u060c\3\2\2\2\u008a\u0616"+ 15928 "\3\2\2\2\u008c\u063f\3\2\2\2\u008e\u0641\3\2\2\2\u0090\u070c\3\2\2\2\u0092"+ 15929 "\u070e\3\2\2\2\u0094\u075f\3\2\2\2\u0096\u076c\3\2\2\2\u0098\u00a1\5\4"+ 15930 "\3\2\u0099\u009a\6\2\2\2\u009a\u00a1\7\3\2\2\u009b\u00a1\5\u0094K\2\u009c"+ 15931 "\u00a1\7\5\2\2\u009d\u00a1\7\b\2\2\u009e\u00a1\5\u0096L\2\u009f\u00a1"+ 15932 "\5\u0092J\2\u00a0\u0098\3\2\2\2\u00a0\u0099\3\2\2\2\u00a0\u009b\3\2\2"+ 15933 "\2\u00a0\u009c\3\2\2\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u009f"+ 15934 "\3\2\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3"+ 15935 "\u00b1\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a7\7\3\2\2\u00a6\u00a5\3\2"+ 15936 "\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00ab\3\2\2\2\u00a8\u00aa\7\6\2\2\u00a9"+ 15937 "\u00a8\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2"+ 15938 "\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00b0\5\u0090I\2\u00af"+ 15939 "\u00a6\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2"+ 15940 "\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5\7\2\2\3\u00b5"+ 15941 "\3\3\2\2\2\u00b6\u00e6\5\f\7\2\u00b7\u00e6\5h\65\2\u00b8\u00e6\5\22\n"+ 15942 "\2\u00b9\u00e6\5\30\r\2\u00ba\u00e6\5\36\20\2\u00bb\u00e6\5$\23\2\u00bc"+ 15943 "\u00e6\5*\26\2\u00bd\u00e6\5\60\31\2\u00be\u00e6\5\66\34\2\u00bf\u00e6"+ 15944 "\5<\37\2\u00c0\u00e6\5B\"\2\u00c1\u00e6\5H%\2\u00c2\u00e6\5N(\2\u00c3"+ 15945 "\u00e6\5T+\2\u00c4\u00e6\5Z.\2\u00c5\u00e6\5f\64\2\u00c6\u00e6\5`\61\2"+ 15946 "\u00c7\u00e6\5\16\b\2\u00c8\u00e6\5\24\13\2\u00c9\u00e6\5\32\16\2\u00ca"+ 15947 "\u00e6\5 \21\2\u00cb\u00e6\5&\24\2\u00cc\u00e6\5,\27\2\u00cd\u00e6\5\62"+ 15948 "\32\2\u00ce\u00e6\58\35\2\u00cf\u00e6\5> \2\u00d0\u00e6\5D#\2\u00d1\u00e6"+ 15949 "\5J&\2\u00d2\u00e6\5P)\2\u00d3\u00e6\5V,\2\u00d4\u00e6\5b\62\2\u00d5\u00e6"+ 15950 "\5\\/\2\u00d6\u00e6\5\20\t\2\u00d7\u00e6\5\26\f\2\u00d8\u00e6\5\34\17"+ 15951 "\2\u00d9\u00e6\5\"\22\2\u00da\u00e6\5(\25\2\u00db\u00e6\5.\30\2\u00dc"+ 15952 "\u00e6\5\64\33\2\u00dd\u00e6\5:\36\2\u00de\u00e6\5@!\2\u00df\u00e6\5F"+ 15953 "$\2\u00e0\u00e6\5L\'\2\u00e1\u00e6\5R*\2\u00e2\u00e6\5X-\2\u00e3\u00e6"+ 15954 "\5d\63\2\u00e4\u00e6\5^\60\2\u00e5\u00b6\3\2\2\2\u00e5\u00b7\3\2\2\2\u00e5"+ 15955 "\u00b8\3\2\2\2\u00e5\u00b9\3\2\2\2\u00e5\u00ba\3\2\2\2\u00e5\u00bb\3\2"+ 15956 "\2\2\u00e5\u00bc\3\2\2\2\u00e5\u00bd\3\2\2\2\u00e5\u00be\3\2\2\2\u00e5"+ 15957 "\u00bf\3\2\2\2\u00e5\u00c0\3\2\2\2\u00e5\u00c1\3\2\2\2\u00e5\u00c2\3\2"+ 15958 "\2\2\u00e5\u00c3\3\2\2\2\u00e5\u00c4\3\2\2\2\u00e5\u00c5\3\2\2\2\u00e5"+ 15959 "\u00c6\3\2\2\2\u00e5\u00c7\3\2\2\2\u00e5\u00c8\3\2\2\2\u00e5\u00c9\3\2"+ 15960 "\2\2\u00e5\u00ca\3\2\2\2\u00e5\u00cb\3\2\2\2\u00e5\u00cc\3\2\2\2\u00e5"+ 15961 "\u00cd\3\2\2\2\u00e5\u00ce\3\2\2\2\u00e5\u00cf\3\2\2\2\u00e5\u00d0\3\2"+ 15962 "\2\2\u00e5\u00d1\3\2\2\2\u00e5\u00d2\3\2\2\2\u00e5\u00d3\3\2\2\2\u00e5"+ 15963 "\u00d4\3\2\2\2\u00e5\u00d5\3\2\2\2\u00e5\u00d6\3\2\2\2\u00e5\u00d7\3\2"+ 15964 "\2\2\u00e5\u00d8\3\2\2\2\u00e5\u00d9\3\2\2\2\u00e5\u00da\3\2\2\2\u00e5"+ 15965 "\u00db\3\2\2\2\u00e5\u00dc\3\2\2\2\u00e5\u00dd\3\2\2\2\u00e5\u00de\3\2"+ 15966 "\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2\u00e5\u00e1\3\2\2\2\u00e5"+ 15967 "\u00e2\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4\3\2\2\2\u00e6\5\3\2\2\2"+ 15968 "\u00e7\u00e8\7\7\2\2\u00e8\u00ef\7Y\2\2\u00e9\u00ee\5\n\6\2\u00ea\u00ee"+ 15969 "\7\b\2\2\u00eb\u00ee\7\3\2\2\u00ec\u00ee\7\6\2\2\u00ed\u00e9\3\2\2\2\u00ed"+ 15970 "\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec\3\2\2\2\u00ee\u00f1\3\2"+ 15971 "\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\3\2\2\2\u00f1"+ 15972 "\u00ef\3\2\2\2\u00f2\u00f3\79\2\2\u00f3\7\3\2\2\2\u00f4\u00f5\7\7\2\2"+ 15973 "\u00f5\u00f6\7;\2\2\u00f6\u00fa\7Y\2\2\u00f7\u00f9\t\2\2\2\u00f8\u00f7"+ 15974 "\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb"+ 15975 "\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\79\2\2\u00fe\t\3\2\2\2"+ 15976 "\u00ff\u0103\7Y\2\2\u0100\u0102\t\2\2\2\u0101\u0100\3\2\2\2\u0102\u0105"+ 15977 "\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105"+ 15978 "\u0103\3\2\2\2\u0106\u010a\7<\2\2\u0107\u0109\t\2\2\2\u0108\u0107\3\2"+ 15979 "\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b"+ 15980 "\u0110\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0111\7[\2\2\u010e\u0111\5\u0096"+ 15981 "L\2\u010f\u0111\7Y\2\2\u0110\u010d\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u010f"+ 15982 "\3\2\2\2\u0111\13\3\2\2\2\u0112\u011d\5\6\4\2\u0113\u011c\5\4\3\2\u0114"+ 15983 "\u0115\6\7\3\2\u0115\u011c\7\3\2\2\u0116\u011c\5\u0094K\2\u0117\u011c"+ 15984 "\7\5\2\2\u0118\u011c\7\b\2\2\u0119\u011c\5\u0096L\2\u011a\u011c\5\u0092"+ 15985 "J\2\u011b\u0113\3\2\2\2\u011b\u0114\3\2\2\2\u011b\u0116\3\2\2\2\u011b"+ 15986 "\u0117\3\2\2\2\u011b\u0118\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2"+ 15987 "\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+ 15988 "\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\5\b\5\2\u0121\u0133\3\2"+ 15989 "\2\2\u0122\u012d\5\6\4\2\u0123\u012c\5\4\3\2\u0124\u0125\6\7\4\2\u0125"+ 15990 "\u012c\7\3\2\2\u0126\u012c\5\u0094K\2\u0127\u012c\7\5\2\2\u0128\u012c"+ 15991 "\7\b\2\2\u0129\u012c\5\u0096L\2\u012a\u012c\5\u0092J\2\u012b\u0123\3\2"+ 15992 "\2\2\u012b\u0124\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012b"+ 15993 "\u0128\3\2\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f\3\2"+ 15994 "\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0130\3\2\2\2\u012f"+ 15995 "\u012d\3\2\2\2\u0130\u0131\b\7\1\2\u0131\u0133\3\2\2\2\u0132\u0112\3\2"+ 15996 "\2\2\u0132\u0122\3\2\2\2\u0133\r\3\2\2\2\u0134\u0135\7\7\2\2\u0135\u013c"+ 15997 "\7=\2\2\u0136\u013b\5\n\6\2\u0137\u013b\7\b\2\2\u0138\u013b\7\3\2\2\u0139"+ 15998 "\u013b\7\6\2\2\u013a\u0136\3\2\2\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2"+ 15999 "\2\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+ 16000 "\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0140\79"+ 16001 "\2\2\u0140\17\3\2\2\2\u0141\u0142\7\7\2\2\u0142\u0143\7;\2\2\u0143\u0147"+ 16002 "\7=\2\2\u0144\u0146\t\2\2\2\u0145\u0144\3\2\2\2\u0146\u0149\3\2\2\2\u0147"+ 16003 "\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2\u0149\u0147\3\2"+ 16004 "\2\2\u014a\u014b\79\2\2\u014b\21\3\2\2\2\u014c\u0174\5\16\b\2\u014d\u0173"+ 16005 "\5\f\7\2\u014e\u0173\5j\66\2\u014f\u0173\5\30\r\2\u0150\u0173\5\36\20"+ 16006 "\2\u0151\u0173\5$\23\2\u0152\u0173\5*\26\2\u0153\u0173\5\60\31\2\u0154"+ 16007 "\u0173\5\66\34\2\u0155\u0173\5<\37\2\u0156\u0173\5B\"\2\u0157\u0173\5"+ 16008 "H%\2\u0158\u0173\5N(\2\u0159\u0173\5T+\2\u015a\u0173\5Z.\2\u015b\u0173"+ 16009 "\5f\64\2\u015c\u0173\5`\61\2\u015d\u0173\5\24\13\2\u015e\u0173\5\32\16"+ 16010 "\2\u015f\u0173\5 \21\2\u0160\u0173\5&\24\2\u0161\u0173\5,\27\2\u0162\u0173"+ 16011 "\5\62\32\2\u0163\u0173\58\35\2\u0164\u0173\5> \2\u0165\u0173\5D#\2\u0166"+ 16012 "\u0173\5J&\2\u0167\u0173\5P)\2\u0168\u0173\5V,\2\u0169\u0173\5b\62\2\u016a"+ 16013 "\u0173\5\\/\2\u016b\u016c\6\n\5\2\u016c\u0173\7\3\2\2\u016d\u0173\5\u0094"+ 16014 "K\2\u016e\u0173\7\5\2\2\u016f\u0173\7\b\2\2\u0170\u0173\5\u0096L\2\u0171"+ 16015 "\u0173\5\u0092J\2\u0172\u014d\3\2\2\2\u0172\u014e\3\2\2\2\u0172\u014f"+ 16016 "\3\2\2\2\u0172\u0150\3\2\2\2\u0172\u0151\3\2\2\2\u0172\u0152\3\2\2\2\u0172"+ 16017 "\u0153\3\2\2\2\u0172\u0154\3\2\2\2\u0172\u0155\3\2\2\2\u0172\u0156\3\2"+ 16018 "\2\2\u0172\u0157\3\2\2\2\u0172\u0158\3\2\2\2\u0172\u0159\3\2\2\2\u0172"+ 16019 "\u015a\3\2\2\2\u0172\u015b\3\2\2\2\u0172\u015c\3\2\2\2\u0172\u015d\3\2"+ 16020 "\2\2\u0172\u015e\3\2\2\2\u0172\u015f\3\2\2\2\u0172\u0160\3\2\2\2\u0172"+ 16021 "\u0161\3\2\2\2\u0172\u0162\3\2\2\2\u0172\u0163\3\2\2\2\u0172\u0164\3\2"+ 16022 "\2\2\u0172\u0165\3\2\2\2\u0172\u0166\3\2\2\2\u0172\u0167\3\2\2\2\u0172"+ 16023 "\u0168\3\2\2\2\u0172\u0169\3\2\2\2\u0172\u016a\3\2\2\2\u0172\u016b\3\2"+ 16024 "\2\2\u0172\u016d\3\2\2\2\u0172\u016e\3\2\2\2\u0172\u016f\3\2\2\2\u0172"+ 16025 "\u0170\3\2\2\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2"+ 16026 "\2\2\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177"+ 16027 "\u0178\5\20\t\2\u0178\23\3\2\2\2\u0179\u017a\7\7\2\2\u017a\u0181\7>\2"+ 16028 "\2\u017b\u0180\5\n\6\2\u017c\u0180\7\b\2\2\u017d\u0180\7\3\2\2\u017e\u0180"+ 16029 "\7\6\2\2\u017f\u017b\3\2\2\2\u017f\u017c\3\2\2\2\u017f\u017d\3\2\2\2\u017f"+ 16030 "\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+ 16031 "\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\79\2\2\u0185"+ 16032 "\25\3\2\2\2\u0186\u0187\7\7\2\2\u0187\u0188\7;\2\2\u0188\u018c\7>\2\2"+ 16033 "\u0189\u018b\t\2\2\2\u018a\u0189\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a"+ 16034 "\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f"+ 16035 "\u0190\79\2\2\u0190\27\3\2\2\2\u0191\u01b9\5\24\13\2\u0192\u01b8\5\f\7"+ 16036 "\2\u0193\u01b8\5j\66\2\u0194\u01b8\5\22\n\2\u0195\u01b8\5\36\20\2\u0196"+ 16037 "\u01b8\5$\23\2\u0197\u01b8\5*\26\2\u0198\u01b8\5\60\31\2\u0199\u01b8\5"+ 16038 "\66\34\2\u019a\u01b8\5<\37\2\u019b\u01b8\5B\"\2\u019c\u01b8\5H%\2\u019d"+ 16039 "\u01b8\5N(\2\u019e\u01b8\5T+\2\u019f\u01b8\5Z.\2\u01a0\u01b8\5f\64\2\u01a1"+ 16040 "\u01b8\5`\61\2\u01a2\u01b8\5\16\b\2\u01a3\u01b8\5\32\16\2\u01a4\u01b8"+ 16041 "\5 \21\2\u01a5\u01b8\5&\24\2\u01a6\u01b8\5,\27\2\u01a7\u01b8\5\62\32\2"+ 16042 "\u01a8\u01b8\58\35\2\u01a9\u01b8\5> \2\u01aa\u01b8\5D#\2\u01ab\u01b8\5"+ 16043 "J&\2\u01ac\u01b8\5P)\2\u01ad\u01b8\5V,\2\u01ae\u01b8\5b\62\2\u01af\u01b8"+ 16044 "\5\\/\2\u01b0\u01b1\6\r\6\2\u01b1\u01b8\7\3\2\2\u01b2\u01b8\5\u0094K\2"+ 16045 "\u01b3\u01b8\7\5\2\2\u01b4\u01b8\7\b\2\2\u01b5\u01b8\5\u0096L\2\u01b6"+ 16046 "\u01b8\5\u0092J\2\u01b7\u0192\3\2\2\2\u01b7\u0193\3\2\2\2\u01b7\u0194"+ 16047 "\3\2\2\2\u01b7\u0195\3\2\2\2\u01b7\u0196\3\2\2\2\u01b7\u0197\3\2\2\2\u01b7"+ 16048 "\u0198\3\2\2\2\u01b7\u0199\3\2\2\2\u01b7\u019a\3\2\2\2\u01b7\u019b\3\2"+ 16049 "\2\2\u01b7\u019c\3\2\2\2\u01b7\u019d\3\2\2\2\u01b7\u019e\3\2\2\2\u01b7"+ 16050 "\u019f\3\2\2\2\u01b7\u01a0\3\2\2\2\u01b7\u01a1\3\2\2\2\u01b7\u01a2\3\2"+ 16051 "\2\2\u01b7\u01a3\3\2\2\2\u01b7\u01a4\3\2\2\2\u01b7\u01a5\3\2\2\2\u01b7"+ 16052 "\u01a6\3\2\2\2\u01b7\u01a7\3\2\2\2\u01b7\u01a8\3\2\2\2\u01b7\u01a9\3\2"+ 16053 "\2\2\u01b7\u01aa\3\2\2\2\u01b7\u01ab\3\2\2\2\u01b7\u01ac\3\2\2\2\u01b7"+ 16054 "\u01ad\3\2\2\2\u01b7\u01ae\3\2\2\2\u01b7\u01af\3\2\2\2\u01b7\u01b0\3\2"+ 16055 "\2\2\u01b7\u01b2\3\2\2\2\u01b7\u01b3\3\2\2\2\u01b7\u01b4\3\2\2\2\u01b7"+ 16056 "\u01b5\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2"+ 16057 "\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc"+ 16058 "\u01bd\5\26\f\2\u01bd\31\3\2\2\2\u01be\u01bf\7\7\2\2\u01bf\u01c6\7?\2"+ 16059 "\2\u01c0\u01c5\5\n\6\2\u01c1\u01c5\7\b\2\2\u01c2\u01c5\7\3\2\2\u01c3\u01c5"+ 16060 "\7\6\2\2\u01c4\u01c0\3\2\2\2\u01c4\u01c1\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c4"+ 16061 "\u01c3\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2"+ 16062 "\2\2\u01c7\u01c9\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\79\2\2\u01ca"+ 16063 "\33\3\2\2\2\u01cb\u01cc\7\7\2\2\u01cc\u01cd\7;\2\2\u01cd\u01d1\7?\2\2"+ 16064 "\u01ce\u01d0\t\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+ 16065 "\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d4\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+ 16066 "\u01d5\79\2\2\u01d5\35\3\2\2\2\u01d6\u01fe\5\32\16\2\u01d7\u01fd\5\f\7"+ 16067 "\2\u01d8\u01fd\5j\66\2\u01d9\u01fd\5\22\n\2\u01da\u01fd\5\30\r\2\u01db"+ 16068 "\u01fd\5$\23\2\u01dc\u01fd\5*\26\2\u01dd\u01fd\5\60\31\2\u01de\u01fd\5"+ 16069 "\66\34\2\u01df\u01fd\5<\37\2\u01e0\u01fd\5B\"\2\u01e1\u01fd\5H%\2\u01e2"+ 16070 "\u01fd\5N(\2\u01e3\u01fd\5T+\2\u01e4\u01fd\5Z.\2\u01e5\u01fd\5f\64\2\u01e6"+ 16071 "\u01fd\5`\61\2\u01e7\u01fd\5\16\b\2\u01e8\u01fd\5\24\13\2\u01e9\u01fd"+ 16072 "\5 \21\2\u01ea\u01fd\5&\24\2\u01eb\u01fd\5,\27\2\u01ec\u01fd\5\62\32\2"+ 16073 "\u01ed\u01fd\58\35\2\u01ee\u01fd\5> \2\u01ef\u01fd\5D#\2\u01f0\u01fd\5"+ 16074 "J&\2\u01f1\u01fd\5P)\2\u01f2\u01fd\5V,\2\u01f3\u01fd\5b\62\2\u01f4\u01fd"+ 16075 "\5\\/\2\u01f5\u01f6\6\20\7\2\u01f6\u01fd\7\3\2\2\u01f7\u01fd\5\u0094K"+ 16076 "\2\u01f8\u01fd\7\5\2\2\u01f9\u01fd\7\b\2\2\u01fa\u01fd\5\u0096L\2\u01fb"+ 16077 "\u01fd\5\u0092J\2\u01fc\u01d7\3\2\2\2\u01fc\u01d8\3\2\2\2\u01fc\u01d9"+ 16078 "\3\2\2\2\u01fc\u01da\3\2\2\2\u01fc\u01db\3\2\2\2\u01fc\u01dc\3\2\2\2\u01fc"+ 16079 "\u01dd\3\2\2\2\u01fc\u01de\3\2\2\2\u01fc\u01df\3\2\2\2\u01fc\u01e0\3\2"+ 16080 "\2\2\u01fc\u01e1\3\2\2\2\u01fc\u01e2\3\2\2\2\u01fc\u01e3\3\2\2\2\u01fc"+ 16081 "\u01e4\3\2\2\2\u01fc\u01e5\3\2\2\2\u01fc\u01e6\3\2\2\2\u01fc\u01e7\3\2"+ 16082 "\2\2\u01fc\u01e8\3\2\2\2\u01fc\u01e9\3\2\2\2\u01fc\u01ea\3\2\2\2\u01fc"+ 16083 "\u01eb\3\2\2\2\u01fc\u01ec\3\2\2\2\u01fc\u01ed\3\2\2\2\u01fc\u01ee\3\2"+ 16084 "\2\2\u01fc\u01ef\3\2\2\2\u01fc\u01f0\3\2\2\2\u01fc\u01f1\3\2\2\2\u01fc"+ 16085 "\u01f2\3\2\2\2\u01fc\u01f3\3\2\2\2\u01fc\u01f4\3\2\2\2\u01fc\u01f5\3\2"+ 16086 "\2\2\u01fc\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc"+ 16087 "\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2"+ 16088 "\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201\3\2\2\2\u0200\u01fe\3\2\2\2\u0201"+ 16089 "\u0202\5\34\17\2\u0202\37\3\2\2\2\u0203\u0204\7\7\2\2\u0204\u020b\7@\2"+ 16090 "\2\u0205\u020a\5\n\6\2\u0206\u020a\7\b\2\2\u0207\u020a\7\3\2\2\u0208\u020a"+ 16091 "\7\6\2\2\u0209\u0205\3\2\2\2\u0209\u0206\3\2\2\2\u0209\u0207\3\2\2\2\u0209"+ 16092 "\u0208\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2"+ 16093 "\2\2\u020c\u020e\3\2\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f"+ 16094 "!\3\2\2\2\u0210\u0211\7\7\2\2\u0211\u0212\7;\2\2\u0212\u0216\7@\2\2\u0213"+ 16095 "\u0215\t\2\2\2\u0214\u0213\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2"+ 16096 "\2\2\u0216\u0217\3\2\2\2\u0217\u0219\3\2\2\2\u0218\u0216\3\2\2\2\u0219"+ 16097 "\u021a\79\2\2\u021a#\3\2\2\2\u021b\u0243\5 \21\2\u021c\u0242\5\f\7\2\u021d"+ 16098 "\u0242\5j\66\2\u021e\u0242\5\22\n\2\u021f\u0242\5\30\r\2\u0220\u0242\5"+ 16099 "\36\20\2\u0221\u0242\5*\26\2\u0222\u0242\5\60\31\2\u0223\u0242\5\66\34"+ 16100 "\2\u0224\u0242\5<\37\2\u0225\u0242\5B\"\2\u0226\u0242\5H%\2\u0227\u0242"+ 16101 "\5N(\2\u0228\u0242\5T+\2\u0229\u0242\5Z.\2\u022a\u0242\5f\64\2\u022b\u0242"+ 16102 "\5`\61\2\u022c\u0242\5\16\b\2\u022d\u0242\5\24\13\2\u022e\u0242\5 \21"+ 16103 "\2\u022f\u0242\5&\24\2\u0230\u0242\5,\27\2\u0231\u0242\5\62\32\2\u0232"+ 16104 "\u0242\58\35\2\u0233\u0242\5> \2\u0234\u0242\5D#\2\u0235\u0242\5J&\2\u0236"+ 16105 "\u0242\5P)\2\u0237\u0242\5V,\2\u0238\u0242\5b\62\2\u0239\u0242\5\\/\2"+ 16106 "\u023a\u023b\6\23\b\2\u023b\u0242\7\3\2\2\u023c\u0242\5\u0094K\2\u023d"+ 16107 "\u0242\7\5\2\2\u023e\u0242\7\b\2\2\u023f\u0242\5\u0096L\2\u0240\u0242"+ 16108 "\5\u0092J\2\u0241\u021c\3\2\2\2\u0241\u021d\3\2\2\2\u0241\u021e\3\2\2"+ 16109 "\2\u0241\u021f\3\2\2\2\u0241\u0220\3\2\2\2\u0241\u0221\3\2\2\2\u0241\u0222"+ 16110 "\3\2\2\2\u0241\u0223\3\2\2\2\u0241\u0224\3\2\2\2\u0241\u0225\3\2\2\2\u0241"+ 16111 "\u0226\3\2\2\2\u0241\u0227\3\2\2\2\u0241\u0228\3\2\2\2\u0241\u0229\3\2"+ 16112 "\2\2\u0241\u022a\3\2\2\2\u0241\u022b\3\2\2\2\u0241\u022c\3\2\2\2\u0241"+ 16113 "\u022d\3\2\2\2\u0241\u022e\3\2\2\2\u0241\u022f\3\2\2\2\u0241\u0230\3\2"+ 16114 "\2\2\u0241\u0231\3\2\2\2\u0241\u0232\3\2\2\2\u0241\u0233\3\2\2\2\u0241"+ 16115 "\u0234\3\2\2\2\u0241\u0235\3\2\2\2\u0241\u0236\3\2\2\2\u0241\u0237\3\2"+ 16116 "\2\2\u0241\u0238\3\2\2\2\u0241\u0239\3\2\2\2\u0241\u023a\3\2\2\2\u0241"+ 16117 "\u023c\3\2\2\2\u0241\u023d\3\2\2\2\u0241\u023e\3\2\2\2\u0241\u023f\3\2"+ 16118 "\2\2\u0241\u0240\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243"+ 16119 "\u0244\3\2\2\2\u0244\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\5\""+ 16120 "\22\2\u0247%\3\2\2\2\u0248\u0249\7\7\2\2\u0249\u0250\7A\2\2\u024a\u024f"+ 16121 "\5\n\6\2\u024b\u024f\7\b\2\2\u024c\u024f\7\3\2\2\u024d\u024f\7\6\2\2\u024e"+ 16122 "\u024a\3\2\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2"+ 16123 "\2\2\u024f\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251"+ 16124 "\u0253\3\2\2\2\u0252\u0250\3\2\2\2\u0253\u0254\79\2\2\u0254\'\3\2\2\2"+ 16125 "\u0255\u0256\7\7\2\2\u0256\u0257\7;\2\2\u0257\u025b\7A\2\2\u0258\u025a"+ 16126 "\t\2\2\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b"+ 16127 "\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f\79"+ 16128 "\2\2\u025f)\3\2\2\2\u0260\u0288\5&\24\2\u0261\u0287\5\f\7\2\u0262\u0287"+ 16129 "\5j\66\2\u0263\u0287\5\22\n\2\u0264\u0287\5\30\r\2\u0265\u0287\5\36\20"+ 16130 "\2\u0266\u0287\5$\23\2\u0267\u0287\5\60\31\2\u0268\u0287\5\66\34\2\u0269"+ 16131 "\u0287\5<\37\2\u026a\u0287\5B\"\2\u026b\u0287\5H%\2\u026c\u0287\5N(\2"+ 16132 "\u026d\u0287\5T+\2\u026e\u0287\5Z.\2\u026f\u0287\5f\64\2\u0270\u0287\5"+ 16133 "`\61\2\u0271\u0287\5\16\b\2\u0272\u0287\5\24\13\2\u0273\u0287\5\32\16"+ 16134 "\2\u0274\u0287\5 \21\2\u0275\u0287\5,\27\2\u0276\u0287\5\62\32\2\u0277"+ 16135 "\u0287\58\35\2\u0278\u0287\5> \2\u0279\u0287\5D#\2\u027a\u0287\5J&\2\u027b"+ 16136 "\u0287\5P)\2\u027c\u0287\5V,\2\u027d\u0287\5b\62\2\u027e\u0287\5\\/\2"+ 16137 "\u027f\u0280\6\26\t\2\u0280\u0287\7\3\2\2\u0281\u0287\5\u0094K\2\u0282"+ 16138 "\u0287\7\5\2\2\u0283\u0287\7\b\2\2\u0284\u0287\5\u0096L\2\u0285\u0287"+ 16139 "\5\u0092J\2\u0286\u0261\3\2\2\2\u0286\u0262\3\2\2\2\u0286\u0263\3\2\2"+ 16140 "\2\u0286\u0264\3\2\2\2\u0286\u0265\3\2\2\2\u0286\u0266\3\2\2\2\u0286\u0267"+ 16141 "\3\2\2\2\u0286\u0268\3\2\2\2\u0286\u0269\3\2\2\2\u0286\u026a\3\2\2\2\u0286"+ 16142 "\u026b\3\2\2\2\u0286\u026c\3\2\2\2\u0286\u026d\3\2\2\2\u0286\u026e\3\2"+ 16143 "\2\2\u0286\u026f\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0271\3\2\2\2\u0286"+ 16144 "\u0272\3\2\2\2\u0286\u0273\3\2\2\2\u0286\u0274\3\2\2\2\u0286\u0275\3\2"+ 16145 "\2\2\u0286\u0276\3\2\2\2\u0286\u0277\3\2\2\2\u0286\u0278\3\2\2\2\u0286"+ 16146 "\u0279\3\2\2\2\u0286\u027a\3\2\2\2\u0286\u027b\3\2\2\2\u0286\u027c\3\2"+ 16147 "\2\2\u0286\u027d\3\2\2\2\u0286\u027e\3\2\2\2\u0286\u027f\3\2\2\2\u0286"+ 16148 "\u0281\3\2\2\2\u0286\u0282\3\2\2\2\u0286\u0283\3\2\2\2\u0286\u0284\3\2"+ 16149 "\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+ 16150 "\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\5("+ 16151 "\25\2\u028c+\3\2\2\2\u028d\u028e\7\7\2\2\u028e\u0295\7B\2\2\u028f\u0294"+ 16152 "\5\n\6\2\u0290\u0294\7\b\2\2\u0291\u0294\7\3\2\2\u0292\u0294\7\6\2\2\u0293"+ 16153 "\u028f\3\2\2\2\u0293\u0290\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0292\3\2"+ 16154 "\2\2\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296"+ 16155 "\u0298\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0299\79\2\2\u0299-\3\2\2\2\u029a"+ 16156 "\u029b\7\7\2\2\u029b\u029c\7;\2\2\u029c\u02a0\7B\2\2\u029d\u029f\t\2\2"+ 16157 "\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e\3\2\2\2\u02a0\u02a1"+ 16158 "\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a3\u02a4\79\2\2\u02a4"+ 16159 "/\3\2\2\2\u02a5\u02cd\5,\27\2\u02a6\u02cc\5\f\7\2\u02a7\u02cc\5j\66\2"+ 16160 "\u02a8\u02cc\5\22\n\2\u02a9\u02cc\5\30\r\2\u02aa\u02cc\5\36\20\2\u02ab"+ 16161 "\u02cc\5$\23\2\u02ac\u02cc\5*\26\2\u02ad\u02cc\5\66\34\2\u02ae\u02cc\5"+ 16162 "<\37\2\u02af\u02cc\5B\"\2\u02b0\u02cc\5H%\2\u02b1\u02cc\5N(\2\u02b2\u02cc"+ 16163 "\5T+\2\u02b3\u02cc\5Z.\2\u02b4\u02cc\5f\64\2\u02b5\u02cc\5`\61\2\u02b6"+ 16164 "\u02cc\5\16\b\2\u02b7\u02cc\5\24\13\2\u02b8\u02cc\5\32\16\2\u02b9\u02cc"+ 16165 "\5 \21\2\u02ba\u02cc\5&\24\2\u02bb\u02cc\5\62\32\2\u02bc\u02cc\58\35\2"+ 16166 "\u02bd\u02cc\5> \2\u02be\u02cc\5D#\2\u02bf\u02cc\5J&\2\u02c0\u02cc\5P"+ 16167 ")\2\u02c1\u02cc\5V,\2\u02c2\u02cc\5b\62\2\u02c3\u02cc\5\\/\2\u02c4\u02c5"+ 16168 "\6\31\n\2\u02c5\u02cc\7\3\2\2\u02c6\u02cc\5\u0094K\2\u02c7\u02cc\7\5\2"+ 16169 "\2\u02c8\u02cc\7\b\2\2\u02c9\u02cc\5\u0096L\2\u02ca\u02cc\5\u0092J\2\u02cb"+ 16170 "\u02a6\3\2\2\2\u02cb\u02a7\3\2\2\2\u02cb\u02a8\3\2\2\2\u02cb\u02a9\3\2"+ 16171 "\2\2\u02cb\u02aa\3\2\2\2\u02cb\u02ab\3\2\2\2\u02cb\u02ac\3\2\2\2\u02cb"+ 16172 "\u02ad\3\2\2\2\u02cb\u02ae\3\2\2\2\u02cb\u02af\3\2\2\2\u02cb\u02b0\3\2"+ 16173 "\2\2\u02cb\u02b1\3\2\2\2\u02cb\u02b2\3\2\2\2\u02cb\u02b3\3\2\2\2\u02cb"+ 16174 "\u02b4\3\2\2\2\u02cb\u02b5\3\2\2\2\u02cb\u02b6\3\2\2\2\u02cb\u02b7\3\2"+ 16175 "\2\2\u02cb\u02b8\3\2\2\2\u02cb\u02b9\3\2\2\2\u02cb\u02ba\3\2\2\2\u02cb"+ 16176 "\u02bb\3\2\2\2\u02cb\u02bc\3\2\2\2\u02cb\u02bd\3\2\2\2\u02cb\u02be\3\2"+ 16177 "\2\2\u02cb\u02bf\3\2\2\2\u02cb\u02c0\3\2\2\2\u02cb\u02c1\3\2\2\2\u02cb"+ 16178 "\u02c2\3\2\2\2\u02cb\u02c3\3\2\2\2\u02cb\u02c4\3\2\2\2\u02cb\u02c6\3\2"+ 16179 "\2\2\u02cb\u02c7\3\2\2\2\u02cb\u02c8\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cb"+ 16180 "\u02ca\3\2\2\2\u02cc\u02cf\3\2\2\2\u02cd\u02cb\3\2\2\2\u02cd\u02ce\3\2"+ 16181 "\2\2\u02ce\u02d0\3\2\2\2\u02cf\u02cd\3\2\2\2\u02d0\u02d1\5.\30\2\u02d1"+ 16182 "\61\3\2\2\2\u02d2\u02d3\7\7\2\2\u02d3\u02da\7C\2\2\u02d4\u02d9\5\n\6\2"+ 16183 "\u02d5\u02d9\7\b\2\2\u02d6\u02d9\7\3\2\2\u02d7\u02d9\7\6\2\2\u02d8\u02d4"+ 16184 "\3\2\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d8\u02d7\3\2\2\2\u02d9"+ 16185 "\u02dc\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2"+ 16186 "\2\2\u02dc\u02da\3\2\2\2\u02dd\u02de\79\2\2\u02de\63\3\2\2\2\u02df\u02e0"+ 16187 "\7\7\2\2\u02e0\u02e1\7;\2\2\u02e1\u02e5\7C\2\2\u02e2\u02e4\t\2\2\2\u02e3"+ 16188 "\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2"+ 16189 "\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\79\2\2\u02e9"+ 16190 "\65\3\2\2\2\u02ea\u0312\5\62\32\2\u02eb\u0311\5\f\7\2\u02ec\u0311\5j\66"+ 16191 "\2\u02ed\u0311\5\22\n\2\u02ee\u0311\5\30\r\2\u02ef\u0311\5\36\20\2\u02f0"+ 16192 "\u0311\5$\23\2\u02f1\u0311\5*\26\2\u02f2\u0311\5\60\31\2\u02f3\u0311\5"+ 16193 "<\37\2\u02f4\u0311\5B\"\2\u02f5\u0311\5H%\2\u02f6\u0311\5N(\2\u02f7\u0311"+ 16194 "\5T+\2\u02f8\u0311\5Z.\2\u02f9\u0311\5f\64\2\u02fa\u0311\5`\61\2\u02fb"+ 16195 "\u0311\5\16\b\2\u02fc\u0311\5\24\13\2\u02fd\u0311\5\32\16\2\u02fe\u0311"+ 16196 "\5 \21\2\u02ff\u0311\5&\24\2\u0300\u0311\5,\27\2\u0301\u0311\58\35\2\u0302"+ 16197 "\u0311\5> \2\u0303\u0311\5D#\2\u0304\u0311\5J&\2\u0305\u0311\5P)\2\u0306"+ 16198 "\u0311\5V,\2\u0307\u0311\5b\62\2\u0308\u0311\5\\/\2\u0309\u030a\6\34\13"+ 16199 "\2\u030a\u0311\7\3\2\2\u030b\u0311\5\u0094K\2\u030c\u0311\7\5\2\2\u030d"+ 16200 "\u0311\7\b\2\2\u030e\u0311\5\u0096L\2\u030f\u0311\5\u0092J\2\u0310\u02eb"+ 16201 "\3\2\2\2\u0310\u02ec\3\2\2\2\u0310\u02ed\3\2\2\2\u0310\u02ee\3\2\2\2\u0310"+ 16202 "\u02ef\3\2\2\2\u0310\u02f0\3\2\2\2\u0310\u02f1\3\2\2\2\u0310\u02f2\3\2"+ 16203 "\2\2\u0310\u02f3\3\2\2\2\u0310\u02f4\3\2\2\2\u0310\u02f5\3\2\2\2\u0310"+ 16204 "\u02f6\3\2\2\2\u0310\u02f7\3\2\2\2\u0310\u02f8\3\2\2\2\u0310\u02f9\3\2"+ 16205 "\2\2\u0310\u02fa\3\2\2\2\u0310\u02fb\3\2\2\2\u0310\u02fc\3\2\2\2\u0310"+ 16206 "\u02fd\3\2\2\2\u0310\u02fe\3\2\2\2\u0310\u02ff\3\2\2\2\u0310\u0300\3\2"+ 16207 "\2\2\u0310\u0301\3\2\2\2\u0310\u0302\3\2\2\2\u0310\u0303\3\2\2\2\u0310"+ 16208 "\u0304\3\2\2\2\u0310\u0305\3\2\2\2\u0310\u0306\3\2\2\2\u0310\u0307\3\2"+ 16209 "\2\2\u0310\u0308\3\2\2\2\u0310\u0309\3\2\2\2\u0310\u030b\3\2\2\2\u0310"+ 16210 "\u030c\3\2\2\2\u0310\u030d\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u030f\3\2"+ 16211 "\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+ 16212 "\u0315\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0316\5\64\33\2\u0316\67\3\2"+ 16213 "\2\2\u0317\u0318\7\7\2\2\u0318\u031f\7D\2\2\u0319\u031e\5\n\6\2\u031a"+ 16214 "\u031e\7\b\2\2\u031b\u031e\7\3\2\2\u031c\u031e\7\6\2\2\u031d\u0319\3\2"+ 16215 "\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031c\3\2\2\2\u031e"+ 16216 "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2"+ 16217 "\2\2\u0321\u031f\3\2\2\2\u0322\u0323\79\2\2\u03239\3\2\2\2\u0324\u0325"+ 16218 "\7\7\2\2\u0325\u0326\7;\2\2\u0326\u032a\7D\2\2\u0327\u0329\t\2\2\2\u0328"+ 16219 "\u0327\3\2\2\2\u0329\u032c\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u032b\3\2"+ 16220 "\2\2\u032b\u032d\3\2\2\2\u032c\u032a\3\2\2\2\u032d\u032e\79\2\2\u032e"+ 16221 ";\3\2\2\2\u032f\u0357\58\35\2\u0330\u0356\5\f\7\2\u0331\u0356\5j\66\2"+ 16222 "\u0332\u0356\5\22\n\2\u0333\u0356\5\30\r\2\u0334\u0356\5\36\20\2\u0335"+ 16223 "\u0356\5$\23\2\u0336\u0356\5*\26\2\u0337\u0356\5\60\31\2\u0338\u0356\5"+ 16224 "\66\34\2\u0339\u0356\5B\"\2\u033a\u0356\5H%\2\u033b\u0356\5N(\2\u033c"+ 16225 "\u0356\5T+\2\u033d\u0356\5Z.\2\u033e\u0356\5f\64\2\u033f\u0356\5`\61\2"+ 16226 "\u0340\u0356\5\16\b\2\u0341\u0356\5\24\13\2\u0342\u0356\5\32\16\2\u0343"+ 16227 "\u0356\5 \21\2\u0344\u0356\5&\24\2\u0345\u0356\5,\27\2\u0346\u0356\5\62"+ 16228 "\32\2\u0347\u0356\5> \2\u0348\u0356\5D#\2\u0349\u0356\5J&\2\u034a\u0356"+ 16229 "\5P)\2\u034b\u0356\5V,\2\u034c\u0356\5b\62\2\u034d\u0356\5\\/\2\u034e"+ 16230 "\u034f\6\37\f\2\u034f\u0356\7\3\2\2\u0350\u0356\5\u0094K\2\u0351\u0356"+ 16231 "\7\5\2\2\u0352\u0356\7\b\2\2\u0353\u0356\5\u0096L\2\u0354\u0356\5\u0092"+ 16232 "J\2\u0355\u0330\3\2\2\2\u0355\u0331\3\2\2\2\u0355\u0332\3\2\2\2\u0355"+ 16233 "\u0333\3\2\2\2\u0355\u0334\3\2\2\2\u0355\u0335\3\2\2\2\u0355\u0336\3\2"+ 16234 "\2\2\u0355\u0337\3\2\2\2\u0355\u0338\3\2\2\2\u0355\u0339\3\2\2\2\u0355"+ 16235 "\u033a\3\2\2\2\u0355\u033b\3\2\2\2\u0355\u033c\3\2\2\2\u0355\u033d\3\2"+ 16236 "\2\2\u0355\u033e\3\2\2\2\u0355\u033f\3\2\2\2\u0355\u0340\3\2\2\2\u0355"+ 16237 "\u0341\3\2\2\2\u0355\u0342\3\2\2\2\u0355\u0343\3\2\2\2\u0355\u0344\3\2"+ 16238 "\2\2\u0355\u0345\3\2\2\2\u0355\u0346\3\2\2\2\u0355\u0347\3\2\2\2\u0355"+ 16239 "\u0348\3\2\2\2\u0355\u0349\3\2\2\2\u0355\u034a\3\2\2\2\u0355\u034b\3\2"+ 16240 "\2\2\u0355\u034c\3\2\2\2\u0355\u034d\3\2\2\2\u0355\u034e\3\2\2\2\u0355"+ 16241 "\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0355\u0352\3\2\2\2\u0355\u0353\3\2"+ 16242 "\2\2\u0355\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357"+ 16243 "\u0358\3\2\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\5:"+ 16244 "\36\2\u035b=\3\2\2\2\u035c\u035d\7\7\2\2\u035d\u0364\7E\2\2\u035e\u0363"+ 16245 "\5\n\6\2\u035f\u0363\7\b\2\2\u0360\u0363\7\3\2\2\u0361\u0363\7\6\2\2\u0362"+ 16246 "\u035e\3\2\2\2\u0362\u035f\3\2\2\2\u0362\u0360\3\2\2\2\u0362\u0361\3\2"+ 16247 "\2\2\u0363\u0366\3\2\2\2\u0364\u0362\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+ 16248 "\u0367\3\2\2\2\u0366\u0364\3\2\2\2\u0367\u0368\79\2\2\u0368?\3\2\2\2\u0369"+ 16249 "\u036a\7\7\2\2\u036a\u036b\7;\2\2\u036b\u036f\7E\2\2\u036c\u036e\t\2\2"+ 16250 "\2\u036d\u036c\3\2\2\2\u036e\u0371\3\2\2\2\u036f\u036d\3\2\2\2\u036f\u0370"+ 16251 "\3\2\2\2\u0370\u0372\3\2\2\2\u0371\u036f\3\2\2\2\u0372\u0373\79\2\2\u0373"+ 16252 "A\3\2\2\2\u0374\u039c\5> \2\u0375\u039b\5\f\7\2\u0376\u039b\5j\66\2\u0377"+ 16253 "\u039b\5\22\n\2\u0378\u039b\5\30\r\2\u0379\u039b\5\36\20\2\u037a\u039b"+ 16254 "\5$\23\2\u037b\u039b\5*\26\2\u037c\u039b\5\60\31\2\u037d\u039b\5\66\34"+ 16255 "\2\u037e\u039b\5<\37\2\u037f\u039b\5H%\2\u0380\u039b\5N(\2\u0381\u039b"+ 16256 "\5T+\2\u0382\u039b\5Z.\2\u0383\u039b\5f\64\2\u0384\u039b\5`\61\2\u0385"+ 16257 "\u039b\5\16\b\2\u0386\u039b\5\24\13\2\u0387\u039b\5\32\16\2\u0388\u039b"+ 16258 "\5 \21\2\u0389\u039b\5&\24\2\u038a\u039b\5,\27\2\u038b\u039b\5\62\32\2"+ 16259 "\u038c\u039b\58\35\2\u038d\u039b\5D#\2\u038e\u039b\5J&\2\u038f\u039b\5"+ 16260 "P)\2\u0390\u039b\5V,\2\u0391\u039b\5b\62\2\u0392\u039b\5\\/\2\u0393\u0394"+ 16261 "\6\"\r\2\u0394\u039b\7\3\2\2\u0395\u039b\5\u0094K\2\u0396\u039b\7\5\2"+ 16262 "\2\u0397\u039b\7\b\2\2\u0398\u039b\5\u0096L\2\u0399\u039b\5\u0092J\2\u039a"+ 16263 "\u0375\3\2\2\2\u039a\u0376\3\2\2\2\u039a\u0377\3\2\2\2\u039a\u0378\3\2"+ 16264 "\2\2\u039a\u0379\3\2\2\2\u039a\u037a\3\2\2\2\u039a\u037b\3\2\2\2\u039a"+ 16265 "\u037c\3\2\2\2\u039a\u037d\3\2\2\2\u039a\u037e\3\2\2\2\u039a\u037f\3\2"+ 16266 "\2\2\u039a\u0380\3\2\2\2\u039a\u0381\3\2\2\2\u039a\u0382\3\2\2\2\u039a"+ 16267 "\u0383\3\2\2\2\u039a\u0384\3\2\2\2\u039a\u0385\3\2\2\2\u039a\u0386\3\2"+ 16268 "\2\2\u039a\u0387\3\2\2\2\u039a\u0388\3\2\2\2\u039a\u0389\3\2\2\2\u039a"+ 16269 "\u038a\3\2\2\2\u039a\u038b\3\2\2\2\u039a\u038c\3\2\2\2\u039a\u038d\3\2"+ 16270 "\2\2\u039a\u038e\3\2\2\2\u039a\u038f\3\2\2\2\u039a\u0390\3\2\2\2\u039a"+ 16271 "\u0391\3\2\2\2\u039a\u0392\3\2\2\2\u039a\u0393\3\2\2\2\u039a\u0395\3\2"+ 16272 "\2\2\u039a\u0396\3\2\2\2\u039a\u0397\3\2\2\2\u039a\u0398\3\2\2\2\u039a"+ 16273 "\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2"+ 16274 "\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a0\5@!\2\u03a0C"+ 16275 "\3\2\2\2\u03a1\u03a2\7\7\2\2\u03a2\u03a9\7F\2\2\u03a3\u03a8\5\n\6\2\u03a4"+ 16276 "\u03a8\7\b\2\2\u03a5\u03a8\7\3\2\2\u03a6\u03a8\7\6\2\2\u03a7\u03a3\3\2"+ 16277 "\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6\3\2\2\2\u03a8"+ 16278 "\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ac\3\2"+ 16279 "\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ad\79\2\2\u03adE\3\2\2\2\u03ae\u03af"+ 16280 "\7\7\2\2\u03af\u03b0\7;\2\2\u03b0\u03b4\7F\2\2\u03b1\u03b3\t\2\2\2\u03b2"+ 16281 "\u03b1\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2"+ 16282 "\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b8\79\2\2\u03b8"+ 16283 "G\3\2\2\2\u03b9\u03e1\5D#\2\u03ba\u03e0\5\f\7\2\u03bb\u03e0\5j\66\2\u03bc"+ 16284 "\u03e0\5\22\n\2\u03bd\u03e0\5\30\r\2\u03be\u03e0\5\36\20\2\u03bf\u03e0"+ 16285 "\5$\23\2\u03c0\u03e0\5*\26\2\u03c1\u03e0\5\60\31\2\u03c2\u03e0\5\66\34"+ 16286 "\2\u03c3\u03e0\5<\37\2\u03c4\u03e0\5B\"\2\u03c5\u03e0\5N(\2\u03c6\u03e0"+ 16287 "\5T+\2\u03c7\u03e0\5Z.\2\u03c8\u03e0\5f\64\2\u03c9\u03e0\5`\61\2\u03ca"+ 16288 "\u03e0\5\16\b\2\u03cb\u03e0\5\24\13\2\u03cc\u03e0\5\32\16\2\u03cd\u03e0"+ 16289 "\5 \21\2\u03ce\u03e0\5&\24\2\u03cf\u03e0\5,\27\2\u03d0\u03e0\5\62\32\2"+ 16290 "\u03d1\u03e0\58\35\2\u03d2\u03e0\5> \2\u03d3\u03e0\5J&\2\u03d4\u03e0\5"+ 16291 "P)\2\u03d5\u03e0\5V,\2\u03d6\u03e0\5b\62\2\u03d7\u03e0\5\\/\2\u03d8\u03d9"+ 16292 "\6%\16\2\u03d9\u03e0\7\3\2\2\u03da\u03e0\5\u0094K\2\u03db\u03e0\7\5\2"+ 16293 "\2\u03dc\u03e0\7\b\2\2\u03dd\u03e0\5\u0096L\2\u03de\u03e0\5\u0092J\2\u03df"+ 16294 "\u03ba\3\2\2\2\u03df\u03bb\3\2\2\2\u03df\u03bc\3\2\2\2\u03df\u03bd\3\2"+ 16295 "\2\2\u03df\u03be\3\2\2\2\u03df\u03bf\3\2\2\2\u03df\u03c0\3\2\2\2\u03df"+ 16296 "\u03c1\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03c3\3\2\2\2\u03df\u03c4\3\2"+ 16297 "\2\2\u03df\u03c5\3\2\2\2\u03df\u03c6\3\2\2\2\u03df\u03c7\3\2\2\2\u03df"+ 16298 "\u03c8\3\2\2\2\u03df\u03c9\3\2\2\2\u03df\u03ca\3\2\2\2\u03df\u03cb\3\2"+ 16299 "\2\2\u03df\u03cc\3\2\2\2\u03df\u03cd\3\2\2\2\u03df\u03ce\3\2\2\2\u03df"+ 16300 "\u03cf\3\2\2\2\u03df\u03d0\3\2\2\2\u03df\u03d1\3\2\2\2\u03df\u03d2\3\2"+ 16301 "\2\2\u03df\u03d3\3\2\2\2\u03df\u03d4\3\2\2\2\u03df\u03d5\3\2\2\2\u03df"+ 16302 "\u03d6\3\2\2\2\u03df\u03d7\3\2\2\2\u03df\u03d8\3\2\2\2\u03df\u03da\3\2"+ 16303 "\2\2\u03df\u03db\3\2\2\2\u03df\u03dc\3\2\2\2\u03df\u03dd\3\2\2\2\u03df"+ 16304 "\u03de\3\2\2\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2"+ 16305 "\2\2\u03e2\u03e4\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5F$\2\u03e5I"+ 16306 "\3\2\2\2\u03e6\u03e7\7\7\2\2\u03e7\u03ee\7G\2\2\u03e8\u03ed\5\n\6\2\u03e9"+ 16307 "\u03ed\7\b\2\2\u03ea\u03ed\7\3\2\2\u03eb\u03ed\7\6\2\2\u03ec\u03e8\3\2"+ 16308 "\2\2\u03ec\u03e9\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed"+ 16309 "\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f1\3\2"+ 16310 "\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03f2\79\2\2\u03f2K\3\2\2\2\u03f3\u03f4"+ 16311 "\7\7\2\2\u03f4\u03f5\7;\2\2\u03f5\u03f9\7G\2\2\u03f6\u03f8\t\2\2\2\u03f7"+ 16312 "\u03f6\3\2\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2"+ 16313 "\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03fd\79\2\2\u03fd"+ 16314 "M\3\2\2\2\u03fe\u0426\5J&\2\u03ff\u0425\5\f\7\2\u0400\u0425\5j\66\2\u0401"+ 16315 "\u0425\5\22\n\2\u0402\u0425\5\30\r\2\u0403\u0425\5\36\20\2\u0404\u0425"+ 16316 "\5$\23\2\u0405\u0425\5*\26\2\u0406\u0425\5\60\31\2\u0407\u0425\5\66\34"+ 16317 "\2\u0408\u0425\5<\37\2\u0409\u0425\5B\"\2\u040a\u0425\5H%\2\u040b\u0425"+ 16318 "\5T+\2\u040c\u0425\5Z.\2\u040d\u0425\5f\64\2\u040e\u0425\5`\61\2\u040f"+ 16319 "\u0425\5\16\b\2\u0410\u0425\5\24\13\2\u0411\u0425\5\32\16\2\u0412\u0425"+ 16320 "\5 \21\2\u0413\u0425\5&\24\2\u0414\u0425\5,\27\2\u0415\u0425\5\62\32\2"+ 16321 "\u0416\u0425\58\35\2\u0417\u0425\5> \2\u0418\u0425\5D#\2\u0419\u0425\5"+ 16322 "P)\2\u041a\u0425\5V,\2\u041b\u0425\5b\62\2\u041c\u0425\5\\/\2\u041d\u041e"+ 16323 "\6(\17\2\u041e\u0425\7\3\2\2\u041f\u0425\5\u0094K\2\u0420\u0425\7\5\2"+ 16324 "\2\u0421\u0425\7\b\2\2\u0422\u0425\5\u0096L\2\u0423\u0425\5\u0092J\2\u0424"+ 16325 "\u03ff\3\2\2\2\u0424\u0400\3\2\2\2\u0424\u0401\3\2\2\2\u0424\u0402\3\2"+ 16326 "\2\2\u0424\u0403\3\2\2\2\u0424\u0404\3\2\2\2\u0424\u0405\3\2\2\2\u0424"+ 16327 "\u0406\3\2\2\2\u0424\u0407\3\2\2\2\u0424\u0408\3\2\2\2\u0424\u0409\3\2"+ 16328 "\2\2\u0424\u040a\3\2\2\2\u0424\u040b\3\2\2\2\u0424\u040c\3\2\2\2\u0424"+ 16329 "\u040d\3\2\2\2\u0424\u040e\3\2\2\2\u0424\u040f\3\2\2\2\u0424\u0410\3\2"+ 16330 "\2\2\u0424\u0411\3\2\2\2\u0424\u0412\3\2\2\2\u0424\u0413\3\2\2\2\u0424"+ 16331 "\u0414\3\2\2\2\u0424\u0415\3\2\2\2\u0424\u0416\3\2\2\2\u0424\u0417\3\2"+ 16332 "\2\2\u0424\u0418\3\2\2\2\u0424\u0419\3\2\2\2\u0424\u041a\3\2\2\2\u0424"+ 16333 "\u041b\3\2\2\2\u0424\u041c\3\2\2\2\u0424\u041d\3\2\2\2\u0424\u041f\3\2"+ 16334 "\2\2\u0424\u0420\3\2\2\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424"+ 16335 "\u0423\3\2\2\2\u0425\u0428\3\2\2\2\u0426\u0424\3\2\2\2\u0426\u0427\3\2"+ 16336 "\2\2\u0427\u0429\3\2\2\2\u0428\u0426\3\2\2\2\u0429\u042a\5L\'\2\u042a"+ 16337 "O\3\2\2\2\u042b\u042c\7\7\2\2\u042c\u0433\7H\2\2\u042d\u0432\5\n\6\2\u042e"+ 16338 "\u0432\7\b\2\2\u042f\u0432\7\3\2\2\u0430\u0432\7\6\2\2\u0431\u042d\3\2"+ 16339 "\2\2\u0431\u042e\3\2\2\2\u0431\u042f\3\2\2\2\u0431\u0430\3\2\2\2\u0432"+ 16340 "\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0436\3\2"+ 16341 "\2\2\u0435\u0433\3\2\2\2\u0436\u0437\79\2\2\u0437Q\3\2\2\2\u0438\u0439"+ 16342 "\7\7\2\2\u0439\u043a\7;\2\2\u043a\u043e\7H\2\2\u043b\u043d\t\2\2\2\u043c"+ 16343 "\u043b\3\2\2\2\u043d\u0440\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2"+ 16344 "\2\2\u043f\u0441\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0442\79\2\2\u0442"+ 16345 "S\3\2\2\2\u0443\u046b\5P)\2\u0444\u046a\5\f\7\2\u0445\u046a\5j\66\2\u0446"+ 16346 "\u046a\5\22\n\2\u0447\u046a\5\30\r\2\u0448\u046a\5\36\20\2\u0449\u046a"+ 16347 "\5$\23\2\u044a\u046a\5*\26\2\u044b\u046a\5\60\31\2\u044c\u046a\5\66\34"+ 16348 "\2\u044d\u046a\5<\37\2\u044e\u046a\5B\"\2\u044f\u046a\5H%\2\u0450\u046a"+ 16349 "\5N(\2\u0451\u046a\5Z.\2\u0452\u046a\5f\64\2\u0453\u046a\5`\61\2\u0454"+ 16350 "\u046a\5\16\b\2\u0455\u046a\5\24\13\2\u0456\u046a\5\32\16\2\u0457\u046a"+ 16351 "\5 \21\2\u0458\u046a\5&\24\2\u0459\u046a\5,\27\2\u045a\u046a\5\62\32\2"+ 16352 "\u045b\u046a\58\35\2\u045c\u046a\5> \2\u045d\u046a\5D#\2\u045e\u046a\5"+ 16353 "J&\2\u045f\u046a\5V,\2\u0460\u046a\5b\62\2\u0461\u046a\5\\/\2\u0462\u0463"+ 16354 "\6+\20\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094K\2\u0465\u046a\7\5\2"+ 16355 "\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468\u046a\5\u0092J\2\u0469"+ 16356 "\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469\u0447\3\2"+ 16357 "\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2\2\2\u0469"+ 16358 "\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469\u044e\3\2"+ 16359 "\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2\2\2\u0469"+ 16360 "\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469\u0455\3\2"+ 16361 "\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2\2\2\u0469"+ 16362 "\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469\u045c\3\2"+ 16363 "\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2\2\2\u0469"+ 16364 "\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469\u0464\3\2"+ 16365 "\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2\2\2\u0469"+ 16366 "\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2"+ 16367 "\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5R*\2\u046fU"+ 16368 "\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7I\2\2\u0472\u0477\5\n\6\2\u0473"+ 16369 "\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476\u0472\3\2"+ 16370 "\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477"+ 16371 "\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u047b\3\2"+ 16372 "\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cW\3\2\2\2\u047d\u047e"+ 16373 "\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7I\2\2\u0480\u0482\t\2\2\2\u0481"+ 16374 "\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484\3\2"+ 16375 "\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+ 16376 "Y\3\2\2\2\u0488\u04b0\5V,\2\u0489\u04af\5\f\7\2\u048a\u04af\5j\66\2\u048b"+ 16377 "\u04af\5\22\n\2\u048c\u04af\5\30\r\2\u048d\u04af\5\36\20\2\u048e\u04af"+ 16378 "\5$\23\2\u048f\u04af\5*\26\2\u0490\u04af\5\60\31\2\u0491\u04af\5\66\34"+ 16379 "\2\u0492\u04af\5<\37\2\u0493\u04af\5B\"\2\u0494\u04af\5H%\2\u0495\u04af"+ 16380 "\5N(\2\u0496\u04af\5T+\2\u0497\u04af\5f\64\2\u0498\u04af\5`\61\2\u0499"+ 16381 "\u04af\5\16\b\2\u049a\u04af\5\24\13\2\u049b\u04af\5\32\16\2\u049c\u04af"+ 16382 "\5 \21\2\u049d\u04af\5&\24\2\u049e\u04af\5,\27\2\u049f\u04af\5\62\32\2"+ 16383 "\u04a0\u04af\58\35\2\u04a1\u04af\5> \2\u04a2\u04af\5D#\2\u04a3\u04af\5"+ 16384 "J&\2\u04a4\u04af\5P)\2\u04a5\u04af\5b\62\2\u04a6\u04af\5\\/\2\u04a7\u04a8"+ 16385 "\6.\21\2\u04a8\u04af\7\3\2\2\u04a9\u04af\5\u0094K\2\u04aa\u04af\7\5\2"+ 16386 "\2\u04ab\u04af\7\b\2\2\u04ac\u04af\5\u0096L\2\u04ad\u04af\5\u0092J\2\u04ae"+ 16387 "\u0489\3\2\2\2\u04ae\u048a\3\2\2\2\u04ae\u048b\3\2\2\2\u04ae\u048c\3\2"+ 16388 "\2\2\u04ae\u048d\3\2\2\2\u04ae\u048e\3\2\2\2\u04ae\u048f\3\2\2\2\u04ae"+ 16389 "\u0490\3\2\2\2\u04ae\u0491\3\2\2\2\u04ae\u0492\3\2\2\2\u04ae\u0493\3\2"+ 16390 "\2\2\u04ae\u0494\3\2\2\2\u04ae\u0495\3\2\2\2\u04ae\u0496\3\2\2\2\u04ae"+ 16391 "\u0497\3\2\2\2\u04ae\u0498\3\2\2\2\u04ae\u0499\3\2\2\2\u04ae\u049a\3\2"+ 16392 "\2\2\u04ae\u049b\3\2\2\2\u04ae\u049c\3\2\2\2\u04ae\u049d\3\2\2\2\u04ae"+ 16393 "\u049e\3\2\2\2\u04ae\u049f\3\2\2\2\u04ae\u04a0\3\2\2\2\u04ae\u04a1\3\2"+ 16394 "\2\2\u04ae\u04a2\3\2\2\2\u04ae\u04a3\3\2\2\2\u04ae\u04a4\3\2\2\2\u04ae"+ 16395 "\u04a5\3\2\2\2\u04ae\u04a6\3\2\2\2\u04ae\u04a7\3\2\2\2\u04ae\u04a9\3\2"+ 16396 "\2\2\u04ae\u04aa\3\2\2\2\u04ae\u04ab\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae"+ 16397 "\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b0\u04b1\3\2"+ 16398 "\2\2\u04b1\u04b3\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04b4\5X-\2\u04b4["+ 16399 "\3\2\2\2\u04b5\u04b6\7\7\2\2\u04b6\u04bd\7J\2\2\u04b7\u04bc\5\n\6\2\u04b8"+ 16400 "\u04bc\7\b\2\2\u04b9\u04bc\7\3\2\2\u04ba\u04bc\7\6\2\2\u04bb\u04b7\3\2"+ 16401 "\2\2\u04bb\u04b8\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bb\u04ba\3\2\2\2\u04bc"+ 16402 "\u04bf\3\2\2\2\u04bd\u04bb\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04c0\3\2"+ 16403 "\2\2\u04bf\u04bd\3\2\2\2\u04c0\u04c1\79\2\2\u04c1]\3\2\2\2\u04c2\u04c3"+ 16404 "\7\7\2\2\u04c3\u04c4\7;\2\2\u04c4\u04c8\7J\2\2\u04c5\u04c7\t\2\2\2\u04c6"+ 16405 "\u04c5\3\2\2\2\u04c7\u04ca\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c8\u04c9\3\2"+ 16406 "\2\2\u04c9\u04cb\3\2\2\2\u04ca\u04c8\3\2\2\2\u04cb\u04cc\79\2\2\u04cc"+ 16407 "_\3\2\2\2\u04cd\u04f5\5\\/\2\u04ce\u04f4\5\f\7\2\u04cf\u04f4\5j\66\2\u04d0"+ 16408 "\u04f4\5\22\n\2\u04d1\u04f4\5\30\r\2\u04d2\u04f4\5\36\20\2\u04d3\u04f4"+ 16409 "\5$\23\2\u04d4\u04f4\5*\26\2\u04d5\u04f4\5\60\31\2\u04d6\u04f4\5\66\34"+ 16410 "\2\u04d7\u04f4\5<\37\2\u04d8\u04f4\5B\"\2\u04d9\u04f4\5H%\2\u04da\u04f4"+ 16411 "\5N(\2\u04db\u04f4\5T+\2\u04dc\u04f4\5Z.\2\u04dd\u04f4\5f\64\2\u04de\u04f4"+ 16412 "\5\16\b\2\u04df\u04f4\5\24\13\2\u04e0\u04f4\5\32\16\2\u04e1\u04f4\5 \21"+ 16413 "\2\u04e2\u04f4\5&\24\2\u04e3\u04f4\5,\27\2\u04e4\u04f4\5\62\32\2\u04e5"+ 16414 "\u04f4\58\35\2\u04e6\u04f4\5> \2\u04e7\u04f4\5D#\2\u04e8\u04f4\5J&\2\u04e9"+ 16415 "\u04f4\5P)\2\u04ea\u04f4\5V,\2\u04eb\u04f4\5b\62\2\u04ec\u04ed\6\61\22"+ 16416 "\2\u04ed\u04f4\7\3\2\2\u04ee\u04f4\5\u0094K\2\u04ef\u04f4\7\5\2\2\u04f0"+ 16417 "\u04f4\7\b\2\2\u04f1\u04f4\5\u0096L\2\u04f2\u04f4\5\u0092J\2\u04f3\u04ce"+ 16418 "\3\2\2\2\u04f3\u04cf\3\2\2\2\u04f3\u04d0\3\2\2\2\u04f3\u04d1\3\2\2\2\u04f3"+ 16419 "\u04d2\3\2\2\2\u04f3\u04d3\3\2\2\2\u04f3\u04d4\3\2\2\2\u04f3\u04d5\3\2"+ 16420 "\2\2\u04f3\u04d6\3\2\2\2\u04f3\u04d7\3\2\2\2\u04f3\u04d8\3\2\2\2\u04f3"+ 16421 "\u04d9\3\2\2\2\u04f3\u04da\3\2\2\2\u04f3\u04db\3\2\2\2\u04f3\u04dc\3\2"+ 16422 "\2\2\u04f3\u04dd\3\2\2\2\u04f3\u04de\3\2\2\2\u04f3\u04df\3\2\2\2\u04f3"+ 16423 "\u04e0\3\2\2\2\u04f3\u04e1\3\2\2\2\u04f3\u04e2\3\2\2\2\u04f3\u04e3\3\2"+ 16424 "\2\2\u04f3\u04e4\3\2\2\2\u04f3\u04e5\3\2\2\2\u04f3\u04e6\3\2\2\2\u04f3"+ 16425 "\u04e7\3\2\2\2\u04f3\u04e8\3\2\2\2\u04f3\u04e9\3\2\2\2\u04f3\u04ea\3\2"+ 16426 "\2\2\u04f3\u04eb\3\2\2\2\u04f3\u04ec\3\2\2\2\u04f3\u04ee\3\2\2\2\u04f3"+ 16427 "\u04ef\3\2\2\2\u04f3\u04f0\3\2\2\2\u04f3\u04f1\3\2\2\2\u04f3\u04f2\3\2"+ 16428 "\2\2\u04f4\u04f7\3\2\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6"+ 16429 "\u04f8\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f8\u04f9\5^\60\2\u04f9a\3\2\2\2"+ 16430 "\u04fa\u04fb\7\7\2\2\u04fb\u0502\7K\2\2\u04fc\u0501\5\n\6\2\u04fd\u0501"+ 16431 "\7\b\2\2\u04fe\u0501\7\3\2\2\u04ff\u0501\7\6\2\2\u0500\u04fc\3\2\2\2\u0500"+ 16432 "\u04fd\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u04ff\3\2\2\2\u0501\u0504\3\2"+ 16433 "\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0505\3\2\2\2\u0504"+ 16434 "\u0502\3\2\2\2\u0505\u0506\79\2\2\u0506c\3\2\2\2\u0507\u0508\7\7\2\2\u0508"+ 16435 "\u0509\7;\2\2\u0509\u050d\7K\2\2\u050a\u050c\t\2\2\2\u050b\u050a\3\2\2"+ 16436 "\2\u050c\u050f\3\2\2\2\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u0510"+ 16437 "\3\2\2\2\u050f\u050d\3\2\2\2\u0510\u0511\79\2\2\u0511e\3\2\2\2\u0512\u053a"+ 16438 "\5b\62\2\u0513\u0539\5\f\7\2\u0514\u0539\5j\66\2\u0515\u0539\5\22\n\2"+ 16439 "\u0516\u0539\5\30\r\2\u0517\u0539\5\36\20\2\u0518\u0539\5$\23\2\u0519"+ 16440 "\u0539\5*\26\2\u051a\u0539\5\60\31\2\u051b\u0539\5\66\34\2\u051c\u0539"+ 16441 "\5<\37\2\u051d\u0539\5B\"\2\u051e\u0539\5H%\2\u051f\u0539\5N(\2\u0520"+ 16442 "\u0539\5T+\2\u0521\u0539\5Z.\2\u0522\u0539\5`\61\2\u0523\u0539\5\16\b"+ 16443 "\2\u0524\u0539\5\24\13\2\u0525\u0539\5\32\16\2\u0526\u0539\5 \21\2\u0527"+ 16444 "\u0539\5&\24\2\u0528\u0539\5,\27\2\u0529\u0539\5\62\32\2\u052a\u0539\5"+ 16445 "8\35\2\u052b\u0539\5> \2\u052c\u0539\5D#\2\u052d\u0539\5J&\2\u052e\u0539"+ 16446 "\5P)\2\u052f\u0539\5V,\2\u0530\u0539\5\\/\2\u0531\u0532\6\64\23\2\u0532"+ 16447 "\u0539\7\3\2\2\u0533\u0539\5\u0094K\2\u0534\u0539\7\5\2\2\u0535\u0539"+ 16448 "\7\b\2\2\u0536\u0539\5\u0096L\2\u0537\u0539\5\u0092J\2\u0538\u0513\3\2"+ 16449 "\2\2\u0538\u0514\3\2\2\2\u0538\u0515\3\2\2\2\u0538\u0516\3\2\2\2\u0538"+ 16450 "\u0517\3\2\2\2\u0538\u0518\3\2\2\2\u0538\u0519\3\2\2\2\u0538\u051a\3\2"+ 16451 "\2\2\u0538\u051b\3\2\2\2\u0538\u051c\3\2\2\2\u0538\u051d\3\2\2\2\u0538"+ 16452 "\u051e\3\2\2\2\u0538\u051f\3\2\2\2\u0538\u0520\3\2\2\2\u0538\u0521\3\2"+ 16453 "\2\2\u0538\u0522\3\2\2\2\u0538\u0523\3\2\2\2\u0538\u0524\3\2\2\2\u0538"+ 16454 "\u0525\3\2\2\2\u0538\u0526\3\2\2\2\u0538\u0527\3\2\2\2\u0538\u0528\3\2"+ 16455 "\2\2\u0538\u0529\3\2\2\2\u0538\u052a\3\2\2\2\u0538\u052b\3\2\2\2\u0538"+ 16456 "\u052c\3\2\2\2\u0538\u052d\3\2\2\2\u0538\u052e\3\2\2\2\u0538\u052f\3\2"+ 16457 "\2\2\u0538\u0530\3\2\2\2\u0538\u0531\3\2\2\2\u0538\u0533\3\2\2\2\u0538"+ 16458 "\u0534\3\2\2\2\u0538\u0535\3\2\2\2\u0538\u0536\3\2\2\2\u0538\u0537\3\2"+ 16459 "\2\2\u0539\u053c\3\2\2\2\u053a\u0538\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+ 16460 "\u053d\3\2\2\2\u053c\u053a\3\2\2\2\u053d\u053e\5d\63\2\u053eg\3\2\2\2"+ 16461 "\u053f\u054f\5j\66\2\u0540\u054f\5l\67\2\u0541\u054f\5n8\2\u0542\u054f"+ 16462 "\5p9\2\u0543\u054f\5r:\2\u0544\u054f\5t;\2\u0545\u054f\5v<\2\u0546\u054f"+ 16463 "\5x=\2\u0547\u054f\5z>\2\u0548\u054f\5|?\2\u0549\u054f\5~@\2\u054a\u054f"+ 16464 "\5\u0080A\2\u054b\u054f\5\u0082B\2\u054c\u054f\5\u0084C\2\u054d\u054f"+ 16465 "\5\u0086D\2\u054e\u053f\3\2\2\2\u054e\u0540\3\2\2\2\u054e\u0541\3\2\2"+ 16466 "\2\u054e\u0542\3\2\2\2\u054e\u0543\3\2\2\2\u054e\u0544\3\2\2\2\u054e\u0545"+ 16467 "\3\2\2\2\u054e\u0546\3\2\2\2\u054e\u0547\3\2\2\2\u054e\u0548\3\2\2\2\u054e"+ 16468 "\u0549\3\2\2\2\u054e\u054a\3\2\2\2\u054e\u054b\3\2\2\2\u054e\u054c\3\2"+ 16469 "\2\2\u054e\u054d\3\2\2\2\u054fi\3\2\2\2\u0550\u0551\7\7\2\2\u0551\u0558"+ 16470 "\t\3\2\2\u0552\u0557\5\n\6\2\u0553\u0557\7\b\2\2\u0554\u0557\7\3\2\2\u0555"+ 16471 "\u0557\7\6\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+ 16472 "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+ 16473 "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7:"+ 16474 "\2\2\u055ck\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7L\2\2\u055f\u0564"+ 16475 "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+ 16476 "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+ 16477 "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+ 16478 "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\t\4\2\2\u0569m\3\2\2\2"+ 16479 "\u056a\u056b\7\7\2\2\u056b\u0572\7M\2\2\u056c\u0571\5\n\6\2\u056d\u0571"+ 16480 "\7\b\2\2\u056e\u0571\7\3\2\2\u056f\u0571\7\6\2\2\u0570\u056c\3\2\2\2\u0570"+ 16481 "\u056d\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2"+ 16482 "\2\2\u0572\u0570\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574"+ 16483 "\u0572\3\2\2\2\u0575\u0576\t\4\2\2\u0576o\3\2\2\2\u0577\u0578\7\7\2\2"+ 16484 "\u0578\u057f\7N\2\2\u0579\u057e\5\n\6\2\u057a\u057e\7\b\2\2\u057b\u057e"+ 16485 "\7\3\2\2\u057c\u057e\7\6\2\2\u057d\u0579\3\2\2\2\u057d\u057a\3\2\2\2\u057d"+ 16486 "\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e\u0581\3\2\2\2\u057f\u057d\3\2"+ 16487 "\2\2\u057f\u0580\3\2\2\2\u0580\u0582\3\2\2\2\u0581\u057f\3\2\2\2\u0582"+ 16488 "\u0583\t\4\2\2\u0583q\3\2\2\2\u0584\u0585\7\7\2\2\u0585\u058c\7O\2\2\u0586"+ 16489 "\u058b\5\n\6\2\u0587\u058b\7\b\2\2\u0588\u058b\7\3\2\2\u0589\u058b\7\6"+ 16490 "\2\2\u058a\u0586\3\2\2\2\u058a\u0587\3\2\2\2\u058a\u0588\3\2\2\2\u058a"+ 16491 "\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2\2\2\u058c\u058d\3\2"+ 16492 "\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f\u0590\t\4\2\2\u0590"+ 16493 "s\3\2\2\2\u0591\u0592\7\7\2\2\u0592\u0599\7P\2\2\u0593\u0598\5\n\6\2\u0594"+ 16494 "\u0598\7\b\2\2\u0595\u0598\7\3\2\2\u0596\u0598\7\6\2\2\u0597\u0593\3\2"+ 16495 "\2\2\u0597\u0594\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0596\3\2\2\2\u0598"+ 16496 "\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c\3\2"+ 16497 "\2\2\u059b\u0599\3\2\2\2\u059c\u059d\t\4\2\2\u059du\3\2\2\2\u059e\u059f"+ 16498 "\7\7\2\2\u059f\u05a6\7Q\2\2\u05a0\u05a5\5\n\6\2\u05a1\u05a5\7\b\2\2\u05a2"+ 16499 "\u05a5\7\3\2\2\u05a3\u05a5\7\6\2\2\u05a4\u05a0\3\2\2\2\u05a4\u05a1\3\2"+ 16500 "\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3\3\2\2\2\u05a5\u05a8\3\2\2\2\u05a6"+ 16501 "\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a9\3\2\2\2\u05a8\u05a6\3\2"+ 16502 "\2\2\u05a9\u05aa\t\4\2\2\u05aaw\3\2\2\2\u05ab\u05ac\7\7\2\2\u05ac\u05b3"+ 16503 "\7R\2\2\u05ad\u05b2\5\n\6\2\u05ae\u05b2\7\b\2\2\u05af\u05b2\7\3\2\2\u05b0"+ 16504 "\u05b2\7\6\2\2\u05b1\u05ad\3\2\2\2\u05b1\u05ae\3\2\2\2\u05b1\u05af\3\2"+ 16505 "\2\2\u05b1\u05b0\3\2\2\2\u05b2\u05b5\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b3"+ 16506 "\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b3\3\2\2\2\u05b6\u05b7\t\4"+ 16507 "\2\2\u05b7y\3\2\2\2\u05b8\u05b9\7\7\2\2\u05b9\u05c0\7S\2\2\u05ba\u05bf"+ 16508 "\5\n\6\2\u05bb\u05bf\7\b\2\2\u05bc\u05bf\7\3\2\2\u05bd\u05bf\7\6\2\2\u05be"+ 16509 "\u05ba\3\2\2\2\u05be\u05bb\3\2\2\2\u05be\u05bc\3\2\2\2\u05be\u05bd\3\2"+ 16510 "\2\2\u05bf\u05c2\3\2\2\2\u05c0\u05be\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1"+ 16511 "\u05c3\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c3\u05c4\t\4\2\2\u05c4{\3\2\2\2"+ 16512 "\u05c5\u05c6\7\7\2\2\u05c6\u05cd\7T\2\2\u05c7\u05cc\5\n\6\2\u05c8\u05cc"+ 16513 "\7\b\2\2\u05c9\u05cc\7\3\2\2\u05ca\u05cc\7\6\2\2\u05cb\u05c7\3\2\2\2\u05cb"+ 16514 "\u05c8\3\2\2\2\u05cb\u05c9\3\2\2\2\u05cb\u05ca\3\2\2\2\u05cc\u05cf\3\2"+ 16515 "\2\2\u05cd\u05cb\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05d0\3\2\2\2\u05cf"+ 16516 "\u05cd\3\2\2\2\u05d0\u05d1\t\4\2\2\u05d1}\3\2\2\2\u05d2\u05d3\7\7\2\2"+ 16517 "\u05d3\u05da\7U\2\2\u05d4\u05d9\5\n\6\2\u05d5\u05d9\7\b\2\2\u05d6\u05d9"+ 16518 "\7\3\2\2\u05d7\u05d9\7\6\2\2\u05d8\u05d4\3\2\2\2\u05d8\u05d5\3\2\2\2\u05d8"+ 16519 "\u05d6\3\2\2\2\u05d8\u05d7\3\2\2\2\u05d9\u05dc\3\2\2\2\u05da\u05d8\3\2"+ 16520 "\2\2\u05da\u05db\3\2\2\2\u05db\u05dd\3\2\2\2\u05dc\u05da\3\2\2\2\u05dd"+ 16521 "\u05de\t\4\2\2\u05de\177\3\2\2\2\u05df\u05e0\7\7\2\2\u05e0\u05e7\7V\2"+ 16522 "\2\u05e1\u05e6\5\n\6\2\u05e2\u05e6\7\b\2\2\u05e3\u05e6\7\3\2\2\u05e4\u05e6"+ 16523 "\7\6\2\2\u05e5\u05e1\3\2\2\2\u05e5\u05e2\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5"+ 16524 "\u05e4\3\2\2\2\u05e6\u05e9\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e7\u05e8\3\2"+ 16525 "\2\2\u05e8\u05ea\3\2\2\2\u05e9\u05e7\3\2\2\2\u05ea\u05eb\t\4\2\2\u05eb"+ 16526 "\u0081\3\2\2\2\u05ec\u05ed\7\7\2\2\u05ed\u05f4\7W\2\2\u05ee\u05f3\5\n"+ 16527 "\6\2\u05ef\u05f3\7\b\2\2\u05f0\u05f3\7\3\2\2\u05f1\u05f3\7\6\2\2\u05f2"+ 16528 "\u05ee\3\2\2\2\u05f2\u05ef\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f1\3\2"+ 16529 "\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5"+ 16530 "\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\t\4\2\2\u05f8\u0083\3\2"+ 16531 "\2\2\u05f9\u05fa\7\7\2\2\u05fa\u0601\7X\2\2\u05fb\u0600\5\n\6\2\u05fc"+ 16532 "\u0600\7\b\2\2\u05fd\u0600\7\3\2\2\u05fe\u0600\7\6\2\2\u05ff\u05fb\3\2"+ 16533 "\2\2\u05ff\u05fc\3\2\2\2\u05ff\u05fd\3\2\2\2\u05ff\u05fe\3\2\2\2\u0600"+ 16534 "\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0604\3\2"+ 16535 "\2\2\u0603\u0601\3\2\2\2\u0604\u0605\t\4\2\2\u0605\u0085\3\2\2\2\u0606"+ 16536 "\u0607\7\7\2\2\u0607\u0608\7;\2\2\u0608\u0609\5\u0088E\2\u0609\u060a\7"+ 16537 "9\2\2\u060a\u060b\bD\1\2\u060b\u0087\3\2\2\2\u060c\u060d\t\5\2\2\u060d"+ 16538 "\u0089\3\2\2\2\u060e\u060f\6F\24\2\u060f\u0617\7\3\2\2\u0610\u0617\5\u0094"+ 16539 "K\2\u0611\u0617\7\5\2\2\u0612\u0617\7\b\2\2\u0613\u0617\5\u0096L\2\u0614"+ 16540 "\u0617\5\u0092J\2\u0615\u0617\5\4\3\2\u0616\u060e\3\2\2\2\u0616\u0610"+ 16541 "\3\2\2\2\u0616\u0611\3\2\2\2\u0616\u0612\3\2\2\2\u0616\u0613\3\2\2\2\u0616"+ 16542 "\u0614\3\2\2\2\u0616\u0615\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u0616\3\2"+ 16543 "\2\2\u0618\u0619\3\2\2\2\u0619\u008b\3\2\2\2\u061a\u061e\7\36\2\2\u061b"+ 16544 "\u061d\t\6\2\2\u061c\u061b\3\2\2\2\u061d\u0620\3\2\2\2\u061e\u061c\3\2"+ 16545 "\2\2\u061e\u061f\3\2\2\2\u061f\u0622\3\2\2\2\u0620\u061e\3\2\2\2\u0621"+ 16546 "\u0623\7 \2\2\u0622\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2"+ 16547 "\2\2\u0624\u0626\7#\2\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626"+ 16548 "\u0628\3\2\2\2\u0627\u0629\5\u008eH\2\u0628\u0627\3\2\2\2\u0628\u0629"+ 16549 "\3\2\2\2\u0629\u0640\3\2\2\2\u062a\u062c\t\6\2\2\u062b\u062a\3\2\2\2\u062c"+ 16550 "\u062d\3\2\2\2\u062d\u062b\3\2\2\2\u062d\u062e\3\2\2\2\u062e\u0630\3\2"+ 16551 "\2\2\u062f\u0631\7 \2\2\u0630\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631"+ 16552 "\u0633\3\2\2\2\u0632\u0634\7#\2\2\u0633\u0632\3\2\2\2\u0633\u0634\3\2"+ 16553 "\2\2\u0634\u0636\3\2\2\2\u0635\u0637\5\u008eH\2\u0636\u0635\3\2\2\2\u0636"+ 16554 "\u0637\3\2\2\2\u0637\u0640\3\2\2\2\u0638\u063a\7 \2\2\u0639\u0638\3\2"+ 16555 "\2\2\u0639\u063a\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063d\7#\2\2\u063c"+ 16556 "\u063e\5\u008eH\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0640"+ 16557 "\3\2\2\2\u063f\u061a\3\2\2\2\u063f\u062b\3\2\2\2\u063f\u0639\3\2\2\2\u0640"+ 16558 "\u008d\3\2\2\2\u0641\u0645\7$\2\2\u0642\u0644\t\7\2\2\u0643\u0642\3\2"+ 16559 "\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646"+ 16560 "\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649\7%\2\2\u0649\u008f\3\2"+ 16561 "\2\2\u064a\u064e\7\t\2\2\u064b\u064d\t\b\2\2\u064c\u064b\3\2\2\2\u064d"+ 16562 "\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f\3\2\2\2\u064f\u0652\3\2"+ 16563 "\2\2\u0650\u064e\3\2\2\2\u0651\u0653\5\u008aF\2\u0652\u0651\3\2\2\2\u0652"+ 16564 "\u0653\3\2\2\2\u0653\u070d\3\2\2\2\u0654\u0658\7\n\2\2\u0655\u0657\t\b"+ 16565 "\2\2\u0656\u0655\3\2\2\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+ 16566 "\u0659\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065b\u065d\5\u008a"+ 16567 "F\2\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u070d\3\2\2\2\u065e"+ 16568 "\u0662\7\13\2\2\u065f\u0661\t\b\2\2\u0660\u065f\3\2\2\2\u0661\u0664\3"+ 16569 "\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0666\3\2\2\2\u0664"+ 16570 "\u0662\3\2\2\2\u0665\u0667\7-\2\2\u0666\u0665\3\2\2\2\u0666\u0667\3\2"+ 16571 "\2\2\u0667\u066b\3\2\2\2\u0668\u066a\t\b\2\2\u0669\u0668\3\2\2\2\u066a"+ 16572 "\u066d\3\2\2\2\u066b\u0669\3\2\2\2\u066b\u066c\3\2\2\2\u066c\u066f\3\2"+ 16573 "\2\2\u066d\u066b\3\2\2\2\u066e\u0670\5\u008aF\2\u066f\u066e\3\2\2\2\u066f"+ 16574 "\u0670\3\2\2\2\u0670\u070d\3\2\2\2\u0671\u0675\7\f\2\2\u0672\u0674\t\b"+ 16575 "\2\2\u0673\u0672\3\2\2\2\u0674\u0677\3\2\2\2\u0675\u0673\3\2\2\2\u0675"+ 16576 "\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0675\3\2\2\2\u0678\u067a\7\33"+ 16577 "\2\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067e\3\2\2\2\u067b"+ 16578 "\u067d\t\b\2\2\u067c\u067b\3\2\2\2\u067d\u0680\3\2\2\2\u067e\u067c\3\2"+ 16579 "\2\2\u067e\u067f\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e\3\2\2\2\u0681"+ 16580 "\u0683\5\u008aF\2\u0682\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u070d"+ 16581 "\3\2\2\2\u0684\u0688\7\r\2\2\u0685\u0687\t\b\2\2\u0686\u0685\3\2\2\2\u0687"+ 16582 "\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068c\3\2"+ 16583 "\2\2\u068a\u0688\3\2\2\2\u068b\u068d\5\u008aF\2\u068c\u068b\3\2\2\2\u068c"+ 16584 "\u068d\3\2\2\2\u068d\u070d\3\2\2\2\u068e\u0692\7\16\2\2\u068f\u0691\t"+ 16585 "\b\2\2\u0690\u068f\3\2\2\2\u0691\u0694\3\2\2\2\u0692\u0690\3\2\2\2\u0692"+ 16586 "\u0693\3\2\2\2\u0693\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695\u0697\5\u008c"+ 16587 "G\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069c\3\2\2\2\u0698"+ 16588 "\u069b\7\35\2\2\u0699\u069b\5\4\3\2\u069a\u0698\3\2\2\2\u069a\u0699\3"+ 16589 "\2\2\2\u069b\u069e\3\2\2\2\u069c\u069a\3\2\2\2\u069c\u069d\3\2\2\2\u069d"+ 16590 "\u06a2\3\2\2\2\u069e\u069c\3\2\2\2\u069f\u06a1\t\b\2\2\u06a0\u069f\3\2"+ 16591 "\2\2\u06a1\u06a4\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3"+ 16592 "\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a5\u06a7\5\u008aF\2\u06a6\u06a5"+ 16593 "\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u070d\3\2\2\2\u06a8\u06ac\7\17\2\2"+ 16594 "\u06a9\u06ab\t\b\2\2\u06aa\u06a9\3\2\2\2\u06ab\u06ae\3\2\2\2\u06ac\u06aa"+ 16595 "\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06b0\3\2\2\2\u06ae\u06ac\3\2\2\2\u06af"+ 16596 "\u06b1\t\t\2\2\u06b0\u06af\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b3\3\2"+ 16597 "\2\2\u06b2\u06b4\5\u008aF\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4"+ 16598 "\u070d\3\2\2\2\u06b5\u06b9\7\21\2\2\u06b6\u06b8\t\b\2\2\u06b7\u06b6\3"+ 16599 "\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba"+ 16600 "\u06bd\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5\u008aF\2\u06bd\u06bc"+ 16601 "\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u070d\3\2\2\2\u06bf\u06c3\7\20\2\2"+ 16602 "\u06c0\u06c2\t\b\2\2\u06c1\u06c0\3\2\2\2\u06c2\u06c5\3\2\2\2\u06c3\u06c1"+ 16603 "\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2\2\2\u06c6"+ 16604 "\u06c8\7)\2\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cc\3\2"+ 16605 "\2\2\u06c9\u06cb\t\b\2\2\u06ca\u06c9\3\2\2\2\u06cb\u06ce\3\2\2\2\u06cc"+ 16606 "\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06d0\3\2\2\2\u06ce\u06cc\3\2"+ 16607 "\2\2\u06cf\u06d1\7+\2\2\u06d0\u06cf\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1"+ 16608 "\u06d5\3\2\2\2\u06d2\u06d4\t\b\2\2\u06d3\u06d2\3\2\2\2\u06d4\u06d7\3\2"+ 16609 "\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d9\3\2\2\2\u06d7"+ 16610 "\u06d5\3\2\2\2\u06d8\u06da\5\u008aF\2\u06d9\u06d8\3\2\2\2\u06d9\u06da"+ 16611 "\3\2\2\2\u06da\u070d\3\2\2\2\u06db\u06df\7\22\2\2\u06dc\u06de\t\b\2\2"+ 16612 "\u06dd\u06dc\3\2\2\2\u06de\u06e1\3\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06e0"+ 16613 "\3\2\2\2\u06e0\u06e3\3\2\2\2\u06e1\u06df\3\2\2\2\u06e2\u06e4\5\u008aF"+ 16614 "\2\u06e3\u06e2\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u070d\3\2\2\2\u06e5\u06e9"+ 16615 "\7\23\2\2\u06e6\u06e8\t\b\2\2\u06e7\u06e6\3\2\2\2\u06e8\u06eb\3\2\2\2"+ 16616 "\u06e9\u06e7\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb\u06e9"+ 16617 "\3\2\2\2\u06ec\u06ee\7-\2\2\u06ed\u06ec\3\2\2\2\u06ed\u06ee\3\2\2\2\u06ee"+ 16618 "\u06f2\3\2\2\2\u06ef\u06f1\t\b\2\2\u06f0\u06ef\3\2\2\2\u06f1\u06f4\3\2"+ 16619 "\2\2\u06f2\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f6\3\2\2\2\u06f4"+ 16620 "\u06f2\3\2\2\2\u06f5\u06f7\5\u008aF\2\u06f6\u06f5\3\2\2\2\u06f6\u06f7"+ 16621 "\3\2\2\2\u06f7\u070d\3\2\2\2\u06f8\u06fc\7\24\2\2\u06f9\u06fb\t\b\2\2"+ 16622 "\u06fa\u06f9\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd"+ 16623 "\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06ff\u0701\5\u008aF"+ 16624 "\2\u0700\u06ff\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u070d\3\2\2\2\u0702\u0706"+ 16625 "\7\27\2\2\u0703\u0705\t\b\2\2\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2"+ 16626 "\u0706\u0704\3\2\2\2\u0706\u0707\3\2\2\2\u0707\u070a\3\2\2\2\u0708\u0706"+ 16627 "\3\2\2\2\u0709\u070b\5\u008aF\2\u070a\u0709\3\2\2\2\u070a\u070b\3\2\2"+ 16628 "\2\u070b\u070d\3\2\2\2\u070c\u064a\3\2\2\2\u070c\u0654\3\2\2\2\u070c\u065e"+ 16629 "\3\2\2\2\u070c\u0671\3\2\2\2\u070c\u0684\3\2\2\2\u070c\u068e\3\2\2\2\u070c"+ 16630 "\u06a8\3\2\2\2\u070c\u06b5\3\2\2\2\u070c\u06bf\3\2\2\2\u070c\u06db\3\2"+ 16631 "\2\2\u070c\u06e5\3\2\2\2\u070c\u06f8\3\2\2\2\u070c\u0702\3\2\2\2\u070d"+ 16632 "\u0091\3\2\2\2\u070e\u075b\7\25\2\2\u070f\u0716\7/\2\2\u0710\u0715\7\6"+ 16633 "\2\2\u0711\u0715\7\b\2\2\u0712\u0715\7\3\2\2\u0713\u0715\5\u0096L\2\u0714"+ 16634 "\u0710\3\2\2\2\u0714\u0711\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0713\3\2"+ 16635 "\2\2\u0715\u0718\3\2\2\2\u0716\u0714\3\2\2\2\u0716\u0717\3\2\2\2\u0717"+ 16636 "\u075c\3\2\2\2\u0718\u0716\3\2\2\2\u0719\u071d\7\60\2\2\u071a\u071c\t"+ 16637 "\2\2\2\u071b\u071a\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2\2\2\u071d"+ 16638 "\u071e\3\2\2\2\u071e\u075c\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0724\7\61"+ 16639 "\2\2\u0721\u0723\t\2\2\2\u0722\u0721\3\2\2\2\u0723\u0726\3\2\2\2\u0724"+ 16640 "\u0722\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u075c\3\2\2\2\u0726\u0724\3\2"+ 16641 "\2\2\u0727\u072b\7\62\2\2\u0728\u072a\t\2\2\2\u0729\u0728\3\2\2\2\u072a"+ 16642 "\u072d\3\2\2\2\u072b\u0729\3\2\2\2\u072b\u072c\3\2\2\2\u072c\u072e\3\2"+ 16643 "\2\2\u072d\u072b\3\2\2\2\u072e\u0730\5\u008cG\2\u072f\u0731\5\u008aF\2"+ 16644 "\u0730\u072f\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u075c\3\2\2\2\u0732\u0736"+ 16645 "\7\63\2\2\u0733\u0735\t\2\2\2\u0734\u0733\3\2\2\2\u0735\u0738\3\2\2\2"+ 16646 "\u0736\u0734\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u0739\3\2\2\2\u0738\u0736"+ 16647 "\3\2\2\2\u0739\u073b\5\u008cG\2\u073a\u073c\5\u008aF\2\u073b\u073a\3\2"+ 16648 "\2\2\u073b\u073c\3\2\2\2\u073c\u075c\3\2\2\2\u073d\u0744\7\64\2\2\u073e"+ 16649 "\u0743\7\6\2\2\u073f\u0743\7\b\2\2\u0740\u0743\7\3\2\2\u0741\u0743\5\u0096"+ 16650 "L\2\u0742\u073e\3\2\2\2\u0742\u073f\3\2\2\2\u0742\u0740\3\2\2\2\u0742"+ 16651 "\u0741\3\2\2\2\u0743\u0746\3\2\2\2\u0744\u0742\3\2\2\2\u0744\u0745\3\2"+ 16652 "\2\2\u0745\u075c\3\2\2\2\u0746\u0744\3\2\2\2\u0747\u074b\7\65\2\2\u0748"+ 16653 "\u074a\t\2\2\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749\3\2"+ 16654 "\2\2\u074b\u074c\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+ 16655 "\u0750\5\u008cG\2\u074f\u074e\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u075c"+ 16656 "\3\2\2\2\u0751\u0755\7\27\2\2\u0752\u0754\t\2\2\2\u0753\u0752\3\2\2\2"+ 16657 "\u0754\u0757\3\2\2\2\u0755\u0753\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0759"+ 16658 "\3\2\2\2\u0757\u0755\3\2\2\2\u0758\u075a\5\u008aF\2\u0759\u0758\3\2\2"+ 16659 "\2\u0759\u075a\3\2\2\2\u075a\u075c\3\2\2\2\u075b\u070f\3\2\2\2\u075b\u0719"+ 16660 "\3\2\2\2\u075b\u0720\3\2\2\2\u075b\u0727\3\2\2\2\u075b\u0732\3\2\2\2\u075b"+ 16661 "\u073d\3\2\2\2\u075b\u0747\3\2\2\2\u075b\u0751\3\2\2\2\u075c\u075d\3\2"+ 16662 "\2\2\u075d\u075e\7\26\2\2\u075e\u0093\3\2\2\2\u075f\u0765\7\4\2\2\u0760"+ 16663 "\u0764\5\u0096L\2\u0761\u0764\7\b\2\2\u0762\u0764\7\3\2\2\u0763\u0760"+ 16664 "\3\2\2\2\u0763\u0761\3\2\2\2\u0763\u0762\3\2\2\2\u0764\u0767\3\2\2\2\u0765"+ 16665 "\u0763\3\2\2\2\u0765\u0766\3\2\2\2\u0766\u0768\3\2\2\2\u0767\u0765\3\2"+ 16666 "\2\2\u0768\u0769\7]\2\2\u0769\u0095\3\2\2\2\u076a\u076b\t\n\2\2\u076b"+ 16667 "\u076d\bL\1\2\u076c\u076a\3\2\2\2\u076d\u076e\3\2\2\2\u076e\u076c\3\2"+ 16668 "\2\2\u076e\u076f\3\2\2\2\u076f\u0097\3\2\2\2\u00c5\u00a0\u00a2\u00a6\u00ab"+ 16669 "\u00b1\u00e5\u00ed\u00ef\u00fa\u0103\u010a\u0110\u011b\u011d\u012b\u012d"+ 16670 "\u0132\u013a\u013c\u0147\u0172\u0174\u017f\u0181\u018c\u01b7\u01b9\u01c4"+ 16671 "\u01c6\u01d1\u01fc\u01fe\u0209\u020b\u0216\u0241\u0243\u024e\u0250\u025b"+ 16672 "\u0286\u0288\u0293\u0295\u02a0\u02cb\u02cd\u02d8\u02da\u02e5\u0310\u0312"+ 16673 "\u031d\u031f\u032a\u0355\u0357\u0362\u0364\u036f\u039a\u039c\u03a7\u03a9"+ 16674 "\u03b4\u03df\u03e1\u03ec\u03ee\u03f9\u0424\u0426\u0431\u0433\u043e\u0469"+ 16675 "\u046b\u0476\u0478\u0483\u04ae\u04b0\u04bb\u04bd\u04c8\u04f3\u04f5\u0500"+ 16676 "\u0502\u050d\u0538\u053a\u054e\u0556\u0558\u0563\u0565\u0570\u0572\u057d"+ 16677 "\u057f\u058a\u058c\u0597\u0599\u05a4\u05a6\u05b1\u05b3\u05be\u05c0\u05cb"+ 16678 "\u05cd\u05d8\u05da\u05e5\u05e7\u05f2\u05f4\u05ff\u0601\u0616\u0618\u061e"+ 16679 "\u0622\u0625\u0628\u062d\u0630\u0633\u0636\u0639\u063d\u063f\u0645\u064e"+ 16680 "\u0652\u0658\u065c\u0662\u0666\u066b\u066f\u0675\u0679\u067e\u0682\u0688"+ 16681 "\u068c\u0692\u0696\u069a\u069c\u06a2\u06a6\u06ac\u06b0\u06b3\u06b9\u06bd"+ 16682 "\u06c3\u06c7\u06cc\u06d0\u06d5\u06d9\u06df\u06e3\u06e9\u06ed\u06f2\u06f6"+ 16683 "\u06fc\u0700\u0706\u070a\u070c\u0714\u0716\u071d\u0724\u072b\u0730\u0736"+ 16684 "\u073b\u0742\u0744\u074b\u074f\u0755\u0759\u075b\u0763\u0765\u076e"; 16685 public static final ATN _ATN = 16686 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 16687 static { 16688 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; 16689 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { 16690 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); 16691 } 16692 } 16693}