001// Generated from com/puppycrawl/tools/checkstyle/grammars/javadoc/JavadocParser.g4 by ANTLR 4.5.2 002package com.puppycrawl.tools.checkstyle.grammars.javadoc; 003import org.antlr.v4.runtime.atn.*; 004import org.antlr.v4.runtime.dfa.DFA; 005import org.antlr.v4.runtime.*; 006import org.antlr.v4.runtime.misc.*; 007import org.antlr.v4.runtime.tree.*; 008import java.util.List; 009import java.util.Iterator; 010import java.util.ArrayList; 011 012@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) 013public class JavadocParser extends Parser { 014 static { RuntimeMetaData.checkVersion("4.5.2", RuntimeMetaData.VERSION); } 015 016 protected static final DFA[] _decisionToDFA; 017 protected static final PredictionContextCache _sharedContextCache = 018 new PredictionContextCache(); 019 public static final int 020 LEADING_ASTERISK=1, HTML_COMMENT_START=2, CDATA=3, WS=4, OPEN=5, NEWLINE=6, 021 AUTHOR_LITERAL=7, DEPRECATED_LITERAL=8, EXCEPTION_LITERAL=9, PARAM_LITERAL=10, 022 RETURN_LITERAL=11, SEE_LITERAL=12, SERIAL_LITERAL=13, SERIAL_FIELD_LITERAL=14, 023 SERIAL_DATA_LITERAL=15, SINCE_LITERAL=16, THROWS_LITERAL=17, VERSION_LITERAL=18, 024 JAVADOC_INLINE_TAG_START=19, JAVADOC_INLINE_TAG_END=20, CUSTOM_NAME=21, 025 LITERAL_INCLUDE=22, LITERAL_EXCLUDE=23, CHAR=24, PARAMETER_NAME=25, Char1=26, 026 STRING=27, PACKAGE=28, DOT=29, HASH=30, CLASS=31, Char2=32, MEMBER=33, 027 LEFT_BRACE=34, RIGHT_BRACE=35, ARGUMENT=36, COMMA=37, Char20=38, FIELD_NAME=39, 028 Char3=40, FIELD_TYPE=41, Char4=42, CLASS_NAME=43, Char5=44, CODE_LITERAL=45, 029 DOC_ROOT_LITERAL=46, INHERIT_DOC_LITERAL=47, LINK_LITERAL=48, LINKPLAIN_LITERAL=49, 030 LITERAL_LITERAL=50, VALUE_LITERAL=51, Char7=52, Char8=53, Char10=54, CLOSE=55, 031 SLASH_CLOSE=56, SLASH=57, EQUALS=58, P_HTML_TAG_NAME=59, LI_HTML_TAG_NAME=60, 032 TR_HTML_TAG_NAME=61, TD_HTML_TAG_NAME=62, TH_HTML_TAG_NAME=63, BODY_HTML_TAG_NAME=64, 033 COLGROUP_HTML_TAG_NAME=65, DD_HTML_TAG_NAME=66, DT_HTML_TAG_NAME=67, HEAD_HTML_TAG_NAME=68, 034 HTML_HTML_TAG_NAME=69, OPTION_HTML_TAG_NAME=70, TBODY_HTML_TAG_NAME=71, 035 TFOOT_HTML_TAG_NAME=72, THEAD_HTML_TAG_NAME=73, AREA_HTML_TAG_NAME=74, 036 BASE_HTML_TAG_NAME=75, 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 _la = _input.LA(1); 340 if (_la==LEADING_ASTERISK) { 341 { 342 setState(163); 343 match(LEADING_ASTERISK); 344 } 345 } 346 347 setState(169); 348 _errHandler.sync(this); 349 _la = _input.LA(1); 350 while (_la==WS) { 351 { 352 { 353 setState(166); 354 match(WS); 355 } 356 } 357 setState(171); 358 _errHandler.sync(this); 359 _la = _input.LA(1); 360 } 361 setState(172); 362 javadocTag(); 363 } 364 } 365 setState(177); 366 _errHandler.sync(this); 367 _la = _input.LA(1); 368 } 369 setState(178); 370 match(EOF); 371 } 372 } 373 catch (RecognitionException re) { 374 _localctx.exception = re; 375 _errHandler.reportError(this, re); 376 _errHandler.recover(this, re); 377 } 378 finally { 379 exitRule(); 380 } 381 return _localctx; 382 } 383 384 public static class HtmlElementContext extends ParserRuleContext { 385 public HtmlTagContext htmlTag() { 386 return getRuleContext(HtmlTagContext.class,0); 387 } 388 public SingletonElementContext singletonElement() { 389 return getRuleContext(SingletonElementContext.class,0); 390 } 391 public ParagraphContext paragraph() { 392 return getRuleContext(ParagraphContext.class,0); 393 } 394 public LiContext li() { 395 return getRuleContext(LiContext.class,0); 396 } 397 public TrContext tr() { 398 return getRuleContext(TrContext.class,0); 399 } 400 public TdContext td() { 401 return getRuleContext(TdContext.class,0); 402 } 403 public ThContext th() { 404 return getRuleContext(ThContext.class,0); 405 } 406 public BodyContext body() { 407 return getRuleContext(BodyContext.class,0); 408 } 409 public ColgroupContext colgroup() { 410 return getRuleContext(ColgroupContext.class,0); 411 } 412 public DdContext dd() { 413 return getRuleContext(DdContext.class,0); 414 } 415 public DtContext dt() { 416 return getRuleContext(DtContext.class,0); 417 } 418 public HeadContext head() { 419 return getRuleContext(HeadContext.class,0); 420 } 421 public HtmlContext html() { 422 return getRuleContext(HtmlContext.class,0); 423 } 424 public OptionContext option() { 425 return getRuleContext(OptionContext.class,0); 426 } 427 public TbodyContext tbody() { 428 return getRuleContext(TbodyContext.class,0); 429 } 430 public TheadContext thead() { 431 return getRuleContext(TheadContext.class,0); 432 } 433 public TfootContext tfoot() { 434 return getRuleContext(TfootContext.class,0); 435 } 436 public PTagOpenContext pTagOpen() { 437 return getRuleContext(PTagOpenContext.class,0); 438 } 439 public LiTagOpenContext liTagOpen() { 440 return getRuleContext(LiTagOpenContext.class,0); 441 } 442 public TrTagOpenContext trTagOpen() { 443 return getRuleContext(TrTagOpenContext.class,0); 444 } 445 public TdTagOpenContext tdTagOpen() { 446 return getRuleContext(TdTagOpenContext.class,0); 447 } 448 public ThTagOpenContext thTagOpen() { 449 return getRuleContext(ThTagOpenContext.class,0); 450 } 451 public BodyTagOpenContext bodyTagOpen() { 452 return getRuleContext(BodyTagOpenContext.class,0); 453 } 454 public ColgroupTagOpenContext colgroupTagOpen() { 455 return getRuleContext(ColgroupTagOpenContext.class,0); 456 } 457 public DdTagOpenContext ddTagOpen() { 458 return getRuleContext(DdTagOpenContext.class,0); 459 } 460 public DtTagOpenContext dtTagOpen() { 461 return getRuleContext(DtTagOpenContext.class,0); 462 } 463 public HeadTagOpenContext headTagOpen() { 464 return getRuleContext(HeadTagOpenContext.class,0); 465 } 466 public HtmlTagOpenContext htmlTagOpen() { 467 return getRuleContext(HtmlTagOpenContext.class,0); 468 } 469 public OptionTagOpenContext optionTagOpen() { 470 return getRuleContext(OptionTagOpenContext.class,0); 471 } 472 public TbodyTagOpenContext tbodyTagOpen() { 473 return getRuleContext(TbodyTagOpenContext.class,0); 474 } 475 public TheadTagOpenContext theadTagOpen() { 476 return getRuleContext(TheadTagOpenContext.class,0); 477 } 478 public TfootTagOpenContext tfootTagOpen() { 479 return getRuleContext(TfootTagOpenContext.class,0); 480 } 481 public PTagCloseContext pTagClose() { 482 return getRuleContext(PTagCloseContext.class,0); 483 } 484 public LiTagCloseContext liTagClose() { 485 return getRuleContext(LiTagCloseContext.class,0); 486 } 487 public TrTagCloseContext trTagClose() { 488 return getRuleContext(TrTagCloseContext.class,0); 489 } 490 public TdTagCloseContext tdTagClose() { 491 return getRuleContext(TdTagCloseContext.class,0); 492 } 493 public ThTagCloseContext thTagClose() { 494 return getRuleContext(ThTagCloseContext.class,0); 495 } 496 public BodyTagCloseContext bodyTagClose() { 497 return getRuleContext(BodyTagCloseContext.class,0); 498 } 499 public ColgroupTagCloseContext colgroupTagClose() { 500 return getRuleContext(ColgroupTagCloseContext.class,0); 501 } 502 public DdTagCloseContext ddTagClose() { 503 return getRuleContext(DdTagCloseContext.class,0); 504 } 505 public DtTagCloseContext dtTagClose() { 506 return getRuleContext(DtTagCloseContext.class,0); 507 } 508 public HeadTagCloseContext headTagClose() { 509 return getRuleContext(HeadTagCloseContext.class,0); 510 } 511 public HtmlTagCloseContext htmlTagClose() { 512 return getRuleContext(HtmlTagCloseContext.class,0); 513 } 514 public OptionTagCloseContext optionTagClose() { 515 return getRuleContext(OptionTagCloseContext.class,0); 516 } 517 public TbodyTagCloseContext tbodyTagClose() { 518 return getRuleContext(TbodyTagCloseContext.class,0); 519 } 520 public TheadTagCloseContext theadTagClose() { 521 return getRuleContext(TheadTagCloseContext.class,0); 522 } 523 public TfootTagCloseContext tfootTagClose() { 524 return getRuleContext(TfootTagCloseContext.class,0); 525 } 526 public HtmlElementContext(ParserRuleContext parent, int invokingState) { 527 super(parent, invokingState); 528 } 529 @Override public int getRuleIndex() { return RULE_htmlElement; } 530 @Override 531 public void enterRule(ParseTreeListener listener) { 532 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElement(this); 533 } 534 @Override 535 public void exitRule(ParseTreeListener listener) { 536 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElement(this); 537 } 538 @Override 539 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 540 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElement(this); 541 else return visitor.visitChildren(this); 542 } 543 } 544 545 public final HtmlElementContext htmlElement() throws RecognitionException { 546 HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState()); 547 enterRule(_localctx, 2, RULE_htmlElement); 548 try { 549 setState(227); 550 _errHandler.sync(this); 551 switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { 552 case 1: 553 enterOuterAlt(_localctx, 1); 554 { 555 setState(180); 556 htmlTag(); 557 } 558 break; 559 case 2: 560 enterOuterAlt(_localctx, 2); 561 { 562 setState(181); 563 singletonElement(); 564 } 565 break; 566 case 3: 567 enterOuterAlt(_localctx, 3); 568 { 569 setState(182); 570 paragraph(); 571 } 572 break; 573 case 4: 574 enterOuterAlt(_localctx, 4); 575 { 576 setState(183); 577 li(); 578 } 579 break; 580 case 5: 581 enterOuterAlt(_localctx, 5); 582 { 583 setState(184); 584 tr(); 585 } 586 break; 587 case 6: 588 enterOuterAlt(_localctx, 6); 589 { 590 setState(185); 591 td(); 592 } 593 break; 594 case 7: 595 enterOuterAlt(_localctx, 7); 596 { 597 setState(186); 598 th(); 599 } 600 break; 601 case 8: 602 enterOuterAlt(_localctx, 8); 603 { 604 setState(187); 605 body(); 606 } 607 break; 608 case 9: 609 enterOuterAlt(_localctx, 9); 610 { 611 setState(188); 612 colgroup(); 613 } 614 break; 615 case 10: 616 enterOuterAlt(_localctx, 10); 617 { 618 setState(189); 619 dd(); 620 } 621 break; 622 case 11: 623 enterOuterAlt(_localctx, 11); 624 { 625 setState(190); 626 dt(); 627 } 628 break; 629 case 12: 630 enterOuterAlt(_localctx, 12); 631 { 632 setState(191); 633 head(); 634 } 635 break; 636 case 13: 637 enterOuterAlt(_localctx, 13); 638 { 639 setState(192); 640 html(); 641 } 642 break; 643 case 14: 644 enterOuterAlt(_localctx, 14); 645 { 646 setState(193); 647 option(); 648 } 649 break; 650 case 15: 651 enterOuterAlt(_localctx, 15); 652 { 653 setState(194); 654 tbody(); 655 } 656 break; 657 case 16: 658 enterOuterAlt(_localctx, 16); 659 { 660 setState(195); 661 thead(); 662 } 663 break; 664 case 17: 665 enterOuterAlt(_localctx, 17); 666 { 667 setState(196); 668 tfoot(); 669 } 670 break; 671 case 18: 672 enterOuterAlt(_localctx, 18); 673 { 674 setState(197); 675 pTagOpen(); 676 } 677 break; 678 case 19: 679 enterOuterAlt(_localctx, 19); 680 { 681 setState(198); 682 liTagOpen(); 683 } 684 break; 685 case 20: 686 enterOuterAlt(_localctx, 20); 687 { 688 setState(199); 689 trTagOpen(); 690 } 691 break; 692 case 21: 693 enterOuterAlt(_localctx, 21); 694 { 695 setState(200); 696 tdTagOpen(); 697 } 698 break; 699 case 22: 700 enterOuterAlt(_localctx, 22); 701 { 702 setState(201); 703 thTagOpen(); 704 } 705 break; 706 case 23: 707 enterOuterAlt(_localctx, 23); 708 { 709 setState(202); 710 bodyTagOpen(); 711 } 712 break; 713 case 24: 714 enterOuterAlt(_localctx, 24); 715 { 716 setState(203); 717 colgroupTagOpen(); 718 } 719 break; 720 case 25: 721 enterOuterAlt(_localctx, 25); 722 { 723 setState(204); 724 ddTagOpen(); 725 } 726 break; 727 case 26: 728 enterOuterAlt(_localctx, 26); 729 { 730 setState(205); 731 dtTagOpen(); 732 } 733 break; 734 case 27: 735 enterOuterAlt(_localctx, 27); 736 { 737 setState(206); 738 headTagOpen(); 739 } 740 break; 741 case 28: 742 enterOuterAlt(_localctx, 28); 743 { 744 setState(207); 745 htmlTagOpen(); 746 } 747 break; 748 case 29: 749 enterOuterAlt(_localctx, 29); 750 { 751 setState(208); 752 optionTagOpen(); 753 } 754 break; 755 case 30: 756 enterOuterAlt(_localctx, 30); 757 { 758 setState(209); 759 tbodyTagOpen(); 760 } 761 break; 762 case 31: 763 enterOuterAlt(_localctx, 31); 764 { 765 setState(210); 766 theadTagOpen(); 767 } 768 break; 769 case 32: 770 enterOuterAlt(_localctx, 32); 771 { 772 setState(211); 773 tfootTagOpen(); 774 } 775 break; 776 case 33: 777 enterOuterAlt(_localctx, 33); 778 { 779 setState(212); 780 pTagClose(); 781 } 782 break; 783 case 34: 784 enterOuterAlt(_localctx, 34); 785 { 786 setState(213); 787 liTagClose(); 788 } 789 break; 790 case 35: 791 enterOuterAlt(_localctx, 35); 792 { 793 setState(214); 794 trTagClose(); 795 } 796 break; 797 case 36: 798 enterOuterAlt(_localctx, 36); 799 { 800 setState(215); 801 tdTagClose(); 802 } 803 break; 804 case 37: 805 enterOuterAlt(_localctx, 37); 806 { 807 setState(216); 808 thTagClose(); 809 } 810 break; 811 case 38: 812 enterOuterAlt(_localctx, 38); 813 { 814 setState(217); 815 bodyTagClose(); 816 } 817 break; 818 case 39: 819 enterOuterAlt(_localctx, 39); 820 { 821 setState(218); 822 colgroupTagClose(); 823 } 824 break; 825 case 40: 826 enterOuterAlt(_localctx, 40); 827 { 828 setState(219); 829 ddTagClose(); 830 } 831 break; 832 case 41: 833 enterOuterAlt(_localctx, 41); 834 { 835 setState(220); 836 dtTagClose(); 837 } 838 break; 839 case 42: 840 enterOuterAlt(_localctx, 42); 841 { 842 setState(221); 843 headTagClose(); 844 } 845 break; 846 case 43: 847 enterOuterAlt(_localctx, 43); 848 { 849 setState(222); 850 htmlTagClose(); 851 } 852 break; 853 case 44: 854 enterOuterAlt(_localctx, 44); 855 { 856 setState(223); 857 optionTagClose(); 858 } 859 break; 860 case 45: 861 enterOuterAlt(_localctx, 45); 862 { 863 setState(224); 864 tbodyTagClose(); 865 } 866 break; 867 case 46: 868 enterOuterAlt(_localctx, 46); 869 { 870 setState(225); 871 theadTagClose(); 872 } 873 break; 874 case 47: 875 enterOuterAlt(_localctx, 47); 876 { 877 setState(226); 878 tfootTagClose(); 879 } 880 break; 881 } 882 } 883 catch (RecognitionException re) { 884 _localctx.exception = re; 885 _errHandler.reportError(this, re); 886 _errHandler.recover(this, re); 887 } 888 finally { 889 exitRule(); 890 } 891 return _localctx; 892 } 893 894 public static class HtmlElementOpenContext extends ParserRuleContext { 895 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 896 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 897 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 898 public List<AttributeContext> attribute() { 899 return getRuleContexts(AttributeContext.class); 900 } 901 public AttributeContext attribute(int i) { 902 return getRuleContext(AttributeContext.class,i); 903 } 904 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 905 public TerminalNode NEWLINE(int i) { 906 return getToken(JavadocParser.NEWLINE, i); 907 } 908 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 909 public TerminalNode LEADING_ASTERISK(int i) { 910 return getToken(JavadocParser.LEADING_ASTERISK, i); 911 } 912 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 913 public TerminalNode WS(int i) { 914 return getToken(JavadocParser.WS, i); 915 } 916 public HtmlElementOpenContext(ParserRuleContext parent, int invokingState) { 917 super(parent, invokingState); 918 } 919 @Override public int getRuleIndex() { return RULE_htmlElementOpen; } 920 @Override 921 public void enterRule(ParseTreeListener listener) { 922 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementOpen(this); 923 } 924 @Override 925 public void exitRule(ParseTreeListener listener) { 926 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementOpen(this); 927 } 928 @Override 929 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 930 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementOpen(this); 931 else return visitor.visitChildren(this); 932 } 933 } 934 935 public final HtmlElementOpenContext htmlElementOpen() throws RecognitionException { 936 HtmlElementOpenContext _localctx = new HtmlElementOpenContext(_ctx, getState()); 937 enterRule(_localctx, 4, RULE_htmlElementOpen); 938 int _la; 939 try { 940 enterOuterAlt(_localctx, 1); 941 { 942 setState(229); 943 match(OPEN); 944 setState(230); 945 match(HTML_TAG_NAME); 946 setState(237); 947 _errHandler.sync(this); 948 _la = _input.LA(1); 949 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 950 { 951 setState(235); 952 switch (_input.LA(1)) { 953 case HTML_TAG_NAME: 954 { 955 setState(231); 956 attribute(); 957 } 958 break; 959 case NEWLINE: 960 { 961 setState(232); 962 match(NEWLINE); 963 } 964 break; 965 case LEADING_ASTERISK: 966 { 967 setState(233); 968 match(LEADING_ASTERISK); 969 } 970 break; 971 case WS: 972 { 973 setState(234); 974 match(WS); 975 } 976 break; 977 default: 978 throw new NoViableAltException(this); 979 } 980 } 981 setState(239); 982 _errHandler.sync(this); 983 _la = _input.LA(1); 984 } 985 setState(240); 986 match(CLOSE); 987 } 988 } 989 catch (RecognitionException re) { 990 _localctx.exception = re; 991 _errHandler.reportError(this, re); 992 _errHandler.recover(this, re); 993 } 994 finally { 995 exitRule(); 996 } 997 return _localctx; 998 } 999 1000 public static class HtmlElementCloseContext extends ParserRuleContext { 1001 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1002 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1003 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 1004 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1005 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1006 public TerminalNode NEWLINE(int i) { 1007 return getToken(JavadocParser.NEWLINE, i); 1008 } 1009 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1010 public TerminalNode LEADING_ASTERISK(int i) { 1011 return getToken(JavadocParser.LEADING_ASTERISK, i); 1012 } 1013 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1014 public TerminalNode WS(int i) { 1015 return getToken(JavadocParser.WS, i); 1016 } 1017 public HtmlElementCloseContext(ParserRuleContext parent, int invokingState) { 1018 super(parent, invokingState); 1019 } 1020 @Override public int getRuleIndex() { return RULE_htmlElementClose; } 1021 @Override 1022 public void enterRule(ParseTreeListener listener) { 1023 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementClose(this); 1024 } 1025 @Override 1026 public void exitRule(ParseTreeListener listener) { 1027 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementClose(this); 1028 } 1029 @Override 1030 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1031 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementClose(this); 1032 else return visitor.visitChildren(this); 1033 } 1034 } 1035 1036 public final HtmlElementCloseContext htmlElementClose() throws RecognitionException { 1037 HtmlElementCloseContext _localctx = new HtmlElementCloseContext(_ctx, getState()); 1038 enterRule(_localctx, 6, RULE_htmlElementClose); 1039 int _la; 1040 try { 1041 enterOuterAlt(_localctx, 1); 1042 { 1043 setState(242); 1044 match(OPEN); 1045 setState(243); 1046 match(SLASH); 1047 setState(244); 1048 match(HTML_TAG_NAME); 1049 setState(248); 1050 _errHandler.sync(this); 1051 _la = _input.LA(1); 1052 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1053 { 1054 { 1055 setState(245); 1056 _la = _input.LA(1); 1057 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1058 _errHandler.recoverInline(this); 1059 } else { 1060 consume(); 1061 } 1062 } 1063 } 1064 setState(250); 1065 _errHandler.sync(this); 1066 _la = _input.LA(1); 1067 } 1068 setState(251); 1069 match(CLOSE); 1070 } 1071 } 1072 catch (RecognitionException re) { 1073 _localctx.exception = re; 1074 _errHandler.reportError(this, re); 1075 _errHandler.recover(this, re); 1076 } 1077 finally { 1078 exitRule(); 1079 } 1080 return _localctx; 1081 } 1082 1083 public static class AttributeContext extends ParserRuleContext { 1084 public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); } 1085 public TerminalNode HTML_TAG_NAME(int i) { 1086 return getToken(JavadocParser.HTML_TAG_NAME, i); 1087 } 1088 public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); } 1089 public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); } 1090 public TextContext text() { 1091 return getRuleContext(TextContext.class,0); 1092 } 1093 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1094 public TerminalNode NEWLINE(int i) { 1095 return getToken(JavadocParser.NEWLINE, i); 1096 } 1097 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1098 public TerminalNode LEADING_ASTERISK(int i) { 1099 return getToken(JavadocParser.LEADING_ASTERISK, i); 1100 } 1101 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1102 public TerminalNode WS(int i) { 1103 return getToken(JavadocParser.WS, i); 1104 } 1105 public AttributeContext(ParserRuleContext parent, int invokingState) { 1106 super(parent, invokingState); 1107 } 1108 @Override public int getRuleIndex() { return RULE_attribute; } 1109 @Override 1110 public void enterRule(ParseTreeListener listener) { 1111 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAttribute(this); 1112 } 1113 @Override 1114 public void exitRule(ParseTreeListener listener) { 1115 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAttribute(this); 1116 } 1117 @Override 1118 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1119 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAttribute(this); 1120 else return visitor.visitChildren(this); 1121 } 1122 } 1123 1124 public final AttributeContext attribute() throws RecognitionException { 1125 AttributeContext _localctx = new AttributeContext(_ctx, getState()); 1126 enterRule(_localctx, 8, RULE_attribute); 1127 int _la; 1128 try { 1129 int _alt; 1130 enterOuterAlt(_localctx, 1); 1131 { 1132 setState(253); 1133 match(HTML_TAG_NAME); 1134 setState(257); 1135 _errHandler.sync(this); 1136 _la = _input.LA(1); 1137 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1138 { 1139 { 1140 setState(254); 1141 _la = _input.LA(1); 1142 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1143 _errHandler.recoverInline(this); 1144 } else { 1145 consume(); 1146 } 1147 } 1148 } 1149 setState(259); 1150 _errHandler.sync(this); 1151 _la = _input.LA(1); 1152 } 1153 setState(260); 1154 match(EQUALS); 1155 setState(264); 1156 _errHandler.sync(this); 1157 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1158 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1159 if ( _alt==1 ) { 1160 { 1161 { 1162 setState(261); 1163 _la = _input.LA(1); 1164 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1165 _errHandler.recoverInline(this); 1166 } else { 1167 consume(); 1168 } 1169 } 1170 } 1171 } 1172 setState(266); 1173 _errHandler.sync(this); 1174 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1175 } 1176 setState(270); 1177 switch (_input.LA(1)) { 1178 case ATTR_VALUE: 1179 { 1180 setState(267); 1181 match(ATTR_VALUE); 1182 } 1183 break; 1184 case WS: 1185 case CHAR: 1186 { 1187 setState(268); 1188 text(); 1189 } 1190 break; 1191 case HTML_TAG_NAME: 1192 { 1193 setState(269); 1194 match(HTML_TAG_NAME); 1195 } 1196 break; 1197 default: 1198 throw new NoViableAltException(this); 1199 } 1200 } 1201 } 1202 catch (RecognitionException re) { 1203 _localctx.exception = re; 1204 _errHandler.reportError(this, re); 1205 _errHandler.recover(this, re); 1206 } 1207 finally { 1208 exitRule(); 1209 } 1210 return _localctx; 1211 } 1212 1213 public static class HtmlTagContext extends ParserRuleContext { 1214 public HtmlElementOpenContext htmlElementOpen; 1215 public HtmlElementOpenContext htmlElementOpen() { 1216 return getRuleContext(HtmlElementOpenContext.class,0); 1217 } 1218 public HtmlElementCloseContext htmlElementClose() { 1219 return getRuleContext(HtmlElementCloseContext.class,0); 1220 } 1221 public List<HtmlElementContext> htmlElement() { 1222 return getRuleContexts(HtmlElementContext.class); 1223 } 1224 public HtmlElementContext htmlElement(int i) { 1225 return getRuleContext(HtmlElementContext.class,i); 1226 } 1227 public List<HtmlCommentContext> htmlComment() { 1228 return getRuleContexts(HtmlCommentContext.class); 1229 } 1230 public HtmlCommentContext htmlComment(int i) { 1231 return getRuleContext(HtmlCommentContext.class,i); 1232 } 1233 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1234 public TerminalNode CDATA(int i) { 1235 return getToken(JavadocParser.CDATA, i); 1236 } 1237 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1238 public TerminalNode NEWLINE(int i) { 1239 return getToken(JavadocParser.NEWLINE, i); 1240 } 1241 public List<TextContext> text() { 1242 return getRuleContexts(TextContext.class); 1243 } 1244 public TextContext text(int i) { 1245 return getRuleContext(TextContext.class,i); 1246 } 1247 public List<JavadocInlineTagContext> javadocInlineTag() { 1248 return getRuleContexts(JavadocInlineTagContext.class); 1249 } 1250 public JavadocInlineTagContext javadocInlineTag(int i) { 1251 return getRuleContext(JavadocInlineTagContext.class,i); 1252 } 1253 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1254 public TerminalNode LEADING_ASTERISK(int i) { 1255 return getToken(JavadocParser.LEADING_ASTERISK, i); 1256 } 1257 public HtmlTagContext(ParserRuleContext parent, int invokingState) { 1258 super(parent, invokingState); 1259 } 1260 @Override public int getRuleIndex() { return RULE_htmlTag; } 1261 @Override 1262 public void enterRule(ParseTreeListener listener) { 1263 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTag(this); 1264 } 1265 @Override 1266 public void exitRule(ParseTreeListener listener) { 1267 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTag(this); 1268 } 1269 @Override 1270 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1271 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTag(this); 1272 else return visitor.visitChildren(this); 1273 } 1274 } 1275 1276 public final HtmlTagContext htmlTag() throws RecognitionException { 1277 HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState()); 1278 enterRule(_localctx, 10, RULE_htmlTag); 1279 try { 1280 int _alt; 1281 setState(304); 1282 _errHandler.sync(this); 1283 switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { 1284 case 1: 1285 enterOuterAlt(_localctx, 1); 1286 { 1287 setState(272); 1288 htmlElementOpen(); 1289 setState(283); 1290 _errHandler.sync(this); 1291 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1292 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1293 if ( _alt==1 ) { 1294 { 1295 setState(281); 1296 _errHandler.sync(this); 1297 switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { 1298 case 1: 1299 { 1300 setState(273); 1301 htmlElement(); 1302 } 1303 break; 1304 case 2: 1305 { 1306 { 1307 setState(274); 1308 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1309 setState(275); 1310 match(LEADING_ASTERISK); 1311 } 1312 } 1313 break; 1314 case 3: 1315 { 1316 setState(276); 1317 htmlComment(); 1318 } 1319 break; 1320 case 4: 1321 { 1322 setState(277); 1323 match(CDATA); 1324 } 1325 break; 1326 case 5: 1327 { 1328 setState(278); 1329 match(NEWLINE); 1330 } 1331 break; 1332 case 6: 1333 { 1334 setState(279); 1335 text(); 1336 } 1337 break; 1338 case 7: 1339 { 1340 setState(280); 1341 javadocInlineTag(); 1342 } 1343 break; 1344 } 1345 } 1346 } 1347 setState(285); 1348 _errHandler.sync(this); 1349 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1350 } 1351 setState(286); 1352 htmlElementClose(); 1353 } 1354 break; 1355 case 2: 1356 enterOuterAlt(_localctx, 2); 1357 { 1358 setState(288); 1359 ((HtmlTagContext)_localctx).htmlElementOpen = htmlElementOpen(); 1360 setState(299); 1361 _errHandler.sync(this); 1362 _alt = getInterpreter().adaptivePredict(_input,15,_ctx); 1363 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1364 if ( _alt==1 ) { 1365 { 1366 setState(297); 1367 _errHandler.sync(this); 1368 switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { 1369 case 1: 1370 { 1371 setState(289); 1372 htmlElement(); 1373 } 1374 break; 1375 case 2: 1376 { 1377 { 1378 setState(290); 1379 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1380 setState(291); 1381 match(LEADING_ASTERISK); 1382 } 1383 } 1384 break; 1385 case 3: 1386 { 1387 setState(292); 1388 htmlComment(); 1389 } 1390 break; 1391 case 4: 1392 { 1393 setState(293); 1394 match(CDATA); 1395 } 1396 break; 1397 case 5: 1398 { 1399 setState(294); 1400 match(NEWLINE); 1401 } 1402 break; 1403 case 6: 1404 { 1405 setState(295); 1406 text(); 1407 } 1408 break; 1409 case 7: 1410 { 1411 setState(296); 1412 javadocInlineTag(); 1413 } 1414 break; 1415 } 1416 } 1417 } 1418 setState(301); 1419 _errHandler.sync(this); 1420 _alt = getInterpreter().adaptivePredict(_input,15,_ctx); 1421 } 1422 notifyErrorListeners(((HtmlTagContext)_localctx).htmlElementOpen.getToken(HTML_TAG_NAME, 0).getSymbol() 1423 , "javadoc.missed.html.close", null); 1424 } 1425 break; 1426 } 1427 } 1428 catch (RecognitionException re) { 1429 _localctx.exception = re; 1430 _errHandler.reportError(this, re); 1431 _errHandler.recover(this, re); 1432 } 1433 finally { 1434 exitRule(); 1435 } 1436 return _localctx; 1437 } 1438 1439 public static class PTagOpenContext extends ParserRuleContext { 1440 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1441 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1442 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1443 public List<AttributeContext> attribute() { 1444 return getRuleContexts(AttributeContext.class); 1445 } 1446 public AttributeContext attribute(int i) { 1447 return getRuleContext(AttributeContext.class,i); 1448 } 1449 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1450 public TerminalNode NEWLINE(int i) { 1451 return getToken(JavadocParser.NEWLINE, i); 1452 } 1453 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1454 public TerminalNode LEADING_ASTERISK(int i) { 1455 return getToken(JavadocParser.LEADING_ASTERISK, i); 1456 } 1457 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1458 public TerminalNode WS(int i) { 1459 return getToken(JavadocParser.WS, i); 1460 } 1461 public PTagOpenContext(ParserRuleContext parent, int invokingState) { 1462 super(parent, invokingState); 1463 } 1464 @Override public int getRuleIndex() { return RULE_pTagOpen; } 1465 @Override 1466 public void enterRule(ParseTreeListener listener) { 1467 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagOpen(this); 1468 } 1469 @Override 1470 public void exitRule(ParseTreeListener listener) { 1471 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagOpen(this); 1472 } 1473 @Override 1474 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1475 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagOpen(this); 1476 else return visitor.visitChildren(this); 1477 } 1478 } 1479 1480 public final PTagOpenContext pTagOpen() throws RecognitionException { 1481 PTagOpenContext _localctx = new PTagOpenContext(_ctx, getState()); 1482 enterRule(_localctx, 12, RULE_pTagOpen); 1483 int _la; 1484 try { 1485 enterOuterAlt(_localctx, 1); 1486 { 1487 setState(306); 1488 match(OPEN); 1489 setState(307); 1490 match(P_HTML_TAG_NAME); 1491 setState(314); 1492 _errHandler.sync(this); 1493 _la = _input.LA(1); 1494 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 1495 { 1496 setState(312); 1497 switch (_input.LA(1)) { 1498 case HTML_TAG_NAME: 1499 { 1500 setState(308); 1501 attribute(); 1502 } 1503 break; 1504 case NEWLINE: 1505 { 1506 setState(309); 1507 match(NEWLINE); 1508 } 1509 break; 1510 case LEADING_ASTERISK: 1511 { 1512 setState(310); 1513 match(LEADING_ASTERISK); 1514 } 1515 break; 1516 case WS: 1517 { 1518 setState(311); 1519 match(WS); 1520 } 1521 break; 1522 default: 1523 throw new NoViableAltException(this); 1524 } 1525 } 1526 setState(316); 1527 _errHandler.sync(this); 1528 _la = _input.LA(1); 1529 } 1530 setState(317); 1531 match(CLOSE); 1532 } 1533 } 1534 catch (RecognitionException re) { 1535 _localctx.exception = re; 1536 _errHandler.reportError(this, re); 1537 _errHandler.recover(this, re); 1538 } 1539 finally { 1540 exitRule(); 1541 } 1542 return _localctx; 1543 } 1544 1545 public static class PTagCloseContext extends ParserRuleContext { 1546 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1547 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1548 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1549 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1550 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1551 public TerminalNode NEWLINE(int i) { 1552 return getToken(JavadocParser.NEWLINE, i); 1553 } 1554 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1555 public TerminalNode LEADING_ASTERISK(int i) { 1556 return getToken(JavadocParser.LEADING_ASTERISK, i); 1557 } 1558 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1559 public TerminalNode WS(int i) { 1560 return getToken(JavadocParser.WS, i); 1561 } 1562 public PTagCloseContext(ParserRuleContext parent, int invokingState) { 1563 super(parent, invokingState); 1564 } 1565 @Override public int getRuleIndex() { return RULE_pTagClose; } 1566 @Override 1567 public void enterRule(ParseTreeListener listener) { 1568 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagClose(this); 1569 } 1570 @Override 1571 public void exitRule(ParseTreeListener listener) { 1572 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagClose(this); 1573 } 1574 @Override 1575 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1576 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagClose(this); 1577 else return visitor.visitChildren(this); 1578 } 1579 } 1580 1581 public final PTagCloseContext pTagClose() throws RecognitionException { 1582 PTagCloseContext _localctx = new PTagCloseContext(_ctx, getState()); 1583 enterRule(_localctx, 14, RULE_pTagClose); 1584 int _la; 1585 try { 1586 enterOuterAlt(_localctx, 1); 1587 { 1588 setState(319); 1589 match(OPEN); 1590 setState(320); 1591 match(SLASH); 1592 setState(321); 1593 match(P_HTML_TAG_NAME); 1594 setState(325); 1595 _errHandler.sync(this); 1596 _la = _input.LA(1); 1597 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1598 { 1599 { 1600 setState(322); 1601 _la = _input.LA(1); 1602 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1603 _errHandler.recoverInline(this); 1604 } else { 1605 consume(); 1606 } 1607 } 1608 } 1609 setState(327); 1610 _errHandler.sync(this); 1611 _la = _input.LA(1); 1612 } 1613 setState(328); 1614 match(CLOSE); 1615 } 1616 } 1617 catch (RecognitionException re) { 1618 _localctx.exception = re; 1619 _errHandler.reportError(this, re); 1620 _errHandler.recover(this, re); 1621 } 1622 finally { 1623 exitRule(); 1624 } 1625 return _localctx; 1626 } 1627 1628 public static class ParagraphContext extends ParserRuleContext { 1629 public PTagOpenContext pTagOpen() { 1630 return getRuleContext(PTagOpenContext.class,0); 1631 } 1632 public PTagCloseContext pTagClose() { 1633 return getRuleContext(PTagCloseContext.class,0); 1634 } 1635 public List<HtmlTagContext> htmlTag() { 1636 return getRuleContexts(HtmlTagContext.class); 1637 } 1638 public HtmlTagContext htmlTag(int i) { 1639 return getRuleContext(HtmlTagContext.class,i); 1640 } 1641 public List<SingletonTagContext> singletonTag() { 1642 return getRuleContexts(SingletonTagContext.class); 1643 } 1644 public SingletonTagContext singletonTag(int i) { 1645 return getRuleContext(SingletonTagContext.class,i); 1646 } 1647 public List<LiContext> li() { 1648 return getRuleContexts(LiContext.class); 1649 } 1650 public LiContext li(int i) { 1651 return getRuleContext(LiContext.class,i); 1652 } 1653 public List<TrContext> tr() { 1654 return getRuleContexts(TrContext.class); 1655 } 1656 public TrContext tr(int i) { 1657 return getRuleContext(TrContext.class,i); 1658 } 1659 public List<TdContext> td() { 1660 return getRuleContexts(TdContext.class); 1661 } 1662 public TdContext td(int i) { 1663 return getRuleContext(TdContext.class,i); 1664 } 1665 public List<ThContext> th() { 1666 return getRuleContexts(ThContext.class); 1667 } 1668 public ThContext th(int i) { 1669 return getRuleContext(ThContext.class,i); 1670 } 1671 public List<BodyContext> body() { 1672 return getRuleContexts(BodyContext.class); 1673 } 1674 public BodyContext body(int i) { 1675 return getRuleContext(BodyContext.class,i); 1676 } 1677 public List<ColgroupContext> colgroup() { 1678 return getRuleContexts(ColgroupContext.class); 1679 } 1680 public ColgroupContext colgroup(int i) { 1681 return getRuleContext(ColgroupContext.class,i); 1682 } 1683 public List<DdContext> dd() { 1684 return getRuleContexts(DdContext.class); 1685 } 1686 public DdContext dd(int i) { 1687 return getRuleContext(DdContext.class,i); 1688 } 1689 public List<DtContext> dt() { 1690 return getRuleContexts(DtContext.class); 1691 } 1692 public DtContext dt(int i) { 1693 return getRuleContext(DtContext.class,i); 1694 } 1695 public List<HeadContext> head() { 1696 return getRuleContexts(HeadContext.class); 1697 } 1698 public HeadContext head(int i) { 1699 return getRuleContext(HeadContext.class,i); 1700 } 1701 public List<HtmlContext> html() { 1702 return getRuleContexts(HtmlContext.class); 1703 } 1704 public HtmlContext html(int i) { 1705 return getRuleContext(HtmlContext.class,i); 1706 } 1707 public List<OptionContext> option() { 1708 return getRuleContexts(OptionContext.class); 1709 } 1710 public OptionContext option(int i) { 1711 return getRuleContext(OptionContext.class,i); 1712 } 1713 public List<TbodyContext> tbody() { 1714 return getRuleContexts(TbodyContext.class); 1715 } 1716 public TbodyContext tbody(int i) { 1717 return getRuleContext(TbodyContext.class,i); 1718 } 1719 public List<TheadContext> thead() { 1720 return getRuleContexts(TheadContext.class); 1721 } 1722 public TheadContext thead(int i) { 1723 return getRuleContext(TheadContext.class,i); 1724 } 1725 public List<TfootContext> tfoot() { 1726 return getRuleContexts(TfootContext.class); 1727 } 1728 public TfootContext tfoot(int i) { 1729 return getRuleContext(TfootContext.class,i); 1730 } 1731 public List<LiTagOpenContext> liTagOpen() { 1732 return getRuleContexts(LiTagOpenContext.class); 1733 } 1734 public LiTagOpenContext liTagOpen(int i) { 1735 return getRuleContext(LiTagOpenContext.class,i); 1736 } 1737 public List<TrTagOpenContext> trTagOpen() { 1738 return getRuleContexts(TrTagOpenContext.class); 1739 } 1740 public TrTagOpenContext trTagOpen(int i) { 1741 return getRuleContext(TrTagOpenContext.class,i); 1742 } 1743 public List<TdTagOpenContext> tdTagOpen() { 1744 return getRuleContexts(TdTagOpenContext.class); 1745 } 1746 public TdTagOpenContext tdTagOpen(int i) { 1747 return getRuleContext(TdTagOpenContext.class,i); 1748 } 1749 public List<ThTagOpenContext> thTagOpen() { 1750 return getRuleContexts(ThTagOpenContext.class); 1751 } 1752 public ThTagOpenContext thTagOpen(int i) { 1753 return getRuleContext(ThTagOpenContext.class,i); 1754 } 1755 public List<BodyTagOpenContext> bodyTagOpen() { 1756 return getRuleContexts(BodyTagOpenContext.class); 1757 } 1758 public BodyTagOpenContext bodyTagOpen(int i) { 1759 return getRuleContext(BodyTagOpenContext.class,i); 1760 } 1761 public List<ColgroupTagOpenContext> colgroupTagOpen() { 1762 return getRuleContexts(ColgroupTagOpenContext.class); 1763 } 1764 public ColgroupTagOpenContext colgroupTagOpen(int i) { 1765 return getRuleContext(ColgroupTagOpenContext.class,i); 1766 } 1767 public List<DdTagOpenContext> ddTagOpen() { 1768 return getRuleContexts(DdTagOpenContext.class); 1769 } 1770 public DdTagOpenContext ddTagOpen(int i) { 1771 return getRuleContext(DdTagOpenContext.class,i); 1772 } 1773 public List<DtTagOpenContext> dtTagOpen() { 1774 return getRuleContexts(DtTagOpenContext.class); 1775 } 1776 public DtTagOpenContext dtTagOpen(int i) { 1777 return getRuleContext(DtTagOpenContext.class,i); 1778 } 1779 public List<HeadTagOpenContext> headTagOpen() { 1780 return getRuleContexts(HeadTagOpenContext.class); 1781 } 1782 public HeadTagOpenContext headTagOpen(int i) { 1783 return getRuleContext(HeadTagOpenContext.class,i); 1784 } 1785 public List<HtmlTagOpenContext> htmlTagOpen() { 1786 return getRuleContexts(HtmlTagOpenContext.class); 1787 } 1788 public HtmlTagOpenContext htmlTagOpen(int i) { 1789 return getRuleContext(HtmlTagOpenContext.class,i); 1790 } 1791 public List<OptionTagOpenContext> optionTagOpen() { 1792 return getRuleContexts(OptionTagOpenContext.class); 1793 } 1794 public OptionTagOpenContext optionTagOpen(int i) { 1795 return getRuleContext(OptionTagOpenContext.class,i); 1796 } 1797 public List<TbodyTagOpenContext> tbodyTagOpen() { 1798 return getRuleContexts(TbodyTagOpenContext.class); 1799 } 1800 public TbodyTagOpenContext tbodyTagOpen(int i) { 1801 return getRuleContext(TbodyTagOpenContext.class,i); 1802 } 1803 public List<TheadTagOpenContext> theadTagOpen() { 1804 return getRuleContexts(TheadTagOpenContext.class); 1805 } 1806 public TheadTagOpenContext theadTagOpen(int i) { 1807 return getRuleContext(TheadTagOpenContext.class,i); 1808 } 1809 public List<TfootTagOpenContext> tfootTagOpen() { 1810 return getRuleContexts(TfootTagOpenContext.class); 1811 } 1812 public TfootTagOpenContext tfootTagOpen(int i) { 1813 return getRuleContext(TfootTagOpenContext.class,i); 1814 } 1815 public List<HtmlCommentContext> htmlComment() { 1816 return getRuleContexts(HtmlCommentContext.class); 1817 } 1818 public HtmlCommentContext htmlComment(int i) { 1819 return getRuleContext(HtmlCommentContext.class,i); 1820 } 1821 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1822 public TerminalNode CDATA(int i) { 1823 return getToken(JavadocParser.CDATA, i); 1824 } 1825 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1826 public TerminalNode NEWLINE(int i) { 1827 return getToken(JavadocParser.NEWLINE, i); 1828 } 1829 public List<TextContext> text() { 1830 return getRuleContexts(TextContext.class); 1831 } 1832 public TextContext text(int i) { 1833 return getRuleContext(TextContext.class,i); 1834 } 1835 public List<JavadocInlineTagContext> javadocInlineTag() { 1836 return getRuleContexts(JavadocInlineTagContext.class); 1837 } 1838 public JavadocInlineTagContext javadocInlineTag(int i) { 1839 return getRuleContext(JavadocInlineTagContext.class,i); 1840 } 1841 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1842 public TerminalNode LEADING_ASTERISK(int i) { 1843 return getToken(JavadocParser.LEADING_ASTERISK, i); 1844 } 1845 public ParagraphContext(ParserRuleContext parent, int invokingState) { 1846 super(parent, invokingState); 1847 } 1848 @Override public int getRuleIndex() { return RULE_paragraph; } 1849 @Override 1850 public void enterRule(ParseTreeListener listener) { 1851 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParagraph(this); 1852 } 1853 @Override 1854 public void exitRule(ParseTreeListener listener) { 1855 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParagraph(this); 1856 } 1857 @Override 1858 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1859 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParagraph(this); 1860 else return visitor.visitChildren(this); 1861 } 1862 } 1863 1864 public final ParagraphContext paragraph() throws RecognitionException { 1865 ParagraphContext _localctx = new ParagraphContext(_ctx, getState()); 1866 enterRule(_localctx, 16, RULE_paragraph); 1867 try { 1868 int _alt; 1869 enterOuterAlt(_localctx, 1); 1870 { 1871 setState(330); 1872 pTagOpen(); 1873 setState(370); 1874 _errHandler.sync(this); 1875 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 1876 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1877 if ( _alt==1 ) { 1878 { 1879 setState(368); 1880 _errHandler.sync(this); 1881 switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) { 1882 case 1: 1883 { 1884 setState(331); 1885 htmlTag(); 1886 } 1887 break; 1888 case 2: 1889 { 1890 setState(332); 1891 singletonTag(); 1892 } 1893 break; 1894 case 3: 1895 { 1896 setState(333); 1897 li(); 1898 } 1899 break; 1900 case 4: 1901 { 1902 setState(334); 1903 tr(); 1904 } 1905 break; 1906 case 5: 1907 { 1908 setState(335); 1909 td(); 1910 } 1911 break; 1912 case 6: 1913 { 1914 setState(336); 1915 th(); 1916 } 1917 break; 1918 case 7: 1919 { 1920 setState(337); 1921 body(); 1922 } 1923 break; 1924 case 8: 1925 { 1926 setState(338); 1927 colgroup(); 1928 } 1929 break; 1930 case 9: 1931 { 1932 setState(339); 1933 dd(); 1934 } 1935 break; 1936 case 10: 1937 { 1938 setState(340); 1939 dt(); 1940 } 1941 break; 1942 case 11: 1943 { 1944 setState(341); 1945 head(); 1946 } 1947 break; 1948 case 12: 1949 { 1950 setState(342); 1951 html(); 1952 } 1953 break; 1954 case 13: 1955 { 1956 setState(343); 1957 option(); 1958 } 1959 break; 1960 case 14: 1961 { 1962 setState(344); 1963 tbody(); 1964 } 1965 break; 1966 case 15: 1967 { 1968 setState(345); 1969 thead(); 1970 } 1971 break; 1972 case 16: 1973 { 1974 setState(346); 1975 tfoot(); 1976 } 1977 break; 1978 case 17: 1979 { 1980 setState(347); 1981 liTagOpen(); 1982 } 1983 break; 1984 case 18: 1985 { 1986 setState(348); 1987 trTagOpen(); 1988 } 1989 break; 1990 case 19: 1991 { 1992 setState(349); 1993 tdTagOpen(); 1994 } 1995 break; 1996 case 20: 1997 { 1998 setState(350); 1999 thTagOpen(); 2000 } 2001 break; 2002 case 21: 2003 { 2004 setState(351); 2005 bodyTagOpen(); 2006 } 2007 break; 2008 case 22: 2009 { 2010 setState(352); 2011 colgroupTagOpen(); 2012 } 2013 break; 2014 case 23: 2015 { 2016 setState(353); 2017 ddTagOpen(); 2018 } 2019 break; 2020 case 24: 2021 { 2022 setState(354); 2023 dtTagOpen(); 2024 } 2025 break; 2026 case 25: 2027 { 2028 setState(355); 2029 headTagOpen(); 2030 } 2031 break; 2032 case 26: 2033 { 2034 setState(356); 2035 htmlTagOpen(); 2036 } 2037 break; 2038 case 27: 2039 { 2040 setState(357); 2041 optionTagOpen(); 2042 } 2043 break; 2044 case 28: 2045 { 2046 setState(358); 2047 tbodyTagOpen(); 2048 } 2049 break; 2050 case 29: 2051 { 2052 setState(359); 2053 theadTagOpen(); 2054 } 2055 break; 2056 case 30: 2057 { 2058 setState(360); 2059 tfootTagOpen(); 2060 } 2061 break; 2062 case 31: 2063 { 2064 { 2065 setState(361); 2066 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2067 setState(362); 2068 match(LEADING_ASTERISK); 2069 } 2070 } 2071 break; 2072 case 32: 2073 { 2074 setState(363); 2075 htmlComment(); 2076 } 2077 break; 2078 case 33: 2079 { 2080 setState(364); 2081 match(CDATA); 2082 } 2083 break; 2084 case 34: 2085 { 2086 setState(365); 2087 match(NEWLINE); 2088 } 2089 break; 2090 case 35: 2091 { 2092 setState(366); 2093 text(); 2094 } 2095 break; 2096 case 36: 2097 { 2098 setState(367); 2099 javadocInlineTag(); 2100 } 2101 break; 2102 } 2103 } 2104 } 2105 setState(372); 2106 _errHandler.sync(this); 2107 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 2108 } 2109 setState(373); 2110 pTagClose(); 2111 } 2112 } 2113 catch (RecognitionException re) { 2114 _localctx.exception = re; 2115 _errHandler.reportError(this, re); 2116 _errHandler.recover(this, re); 2117 } 2118 finally { 2119 exitRule(); 2120 } 2121 return _localctx; 2122 } 2123 2124 public static class LiTagOpenContext extends ParserRuleContext { 2125 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2126 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2127 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2128 public List<AttributeContext> attribute() { 2129 return getRuleContexts(AttributeContext.class); 2130 } 2131 public AttributeContext attribute(int i) { 2132 return getRuleContext(AttributeContext.class,i); 2133 } 2134 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2135 public TerminalNode NEWLINE(int i) { 2136 return getToken(JavadocParser.NEWLINE, i); 2137 } 2138 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2139 public TerminalNode LEADING_ASTERISK(int i) { 2140 return getToken(JavadocParser.LEADING_ASTERISK, i); 2141 } 2142 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2143 public TerminalNode WS(int i) { 2144 return getToken(JavadocParser.WS, i); 2145 } 2146 public LiTagOpenContext(ParserRuleContext parent, int invokingState) { 2147 super(parent, invokingState); 2148 } 2149 @Override public int getRuleIndex() { return RULE_liTagOpen; } 2150 @Override 2151 public void enterRule(ParseTreeListener listener) { 2152 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagOpen(this); 2153 } 2154 @Override 2155 public void exitRule(ParseTreeListener listener) { 2156 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagOpen(this); 2157 } 2158 @Override 2159 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2160 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagOpen(this); 2161 else return visitor.visitChildren(this); 2162 } 2163 } 2164 2165 public final LiTagOpenContext liTagOpen() throws RecognitionException { 2166 LiTagOpenContext _localctx = new LiTagOpenContext(_ctx, getState()); 2167 enterRule(_localctx, 18, RULE_liTagOpen); 2168 int _la; 2169 try { 2170 enterOuterAlt(_localctx, 1); 2171 { 2172 setState(375); 2173 match(OPEN); 2174 setState(376); 2175 match(LI_HTML_TAG_NAME); 2176 setState(383); 2177 _errHandler.sync(this); 2178 _la = _input.LA(1); 2179 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2180 { 2181 setState(381); 2182 switch (_input.LA(1)) { 2183 case HTML_TAG_NAME: 2184 { 2185 setState(377); 2186 attribute(); 2187 } 2188 break; 2189 case NEWLINE: 2190 { 2191 setState(378); 2192 match(NEWLINE); 2193 } 2194 break; 2195 case LEADING_ASTERISK: 2196 { 2197 setState(379); 2198 match(LEADING_ASTERISK); 2199 } 2200 break; 2201 case WS: 2202 { 2203 setState(380); 2204 match(WS); 2205 } 2206 break; 2207 default: 2208 throw new NoViableAltException(this); 2209 } 2210 } 2211 setState(385); 2212 _errHandler.sync(this); 2213 _la = _input.LA(1); 2214 } 2215 setState(386); 2216 match(CLOSE); 2217 } 2218 } 2219 catch (RecognitionException re) { 2220 _localctx.exception = re; 2221 _errHandler.reportError(this, re); 2222 _errHandler.recover(this, re); 2223 } 2224 finally { 2225 exitRule(); 2226 } 2227 return _localctx; 2228 } 2229 2230 public static class LiTagCloseContext extends ParserRuleContext { 2231 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2232 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2233 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2234 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2235 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2236 public TerminalNode NEWLINE(int i) { 2237 return getToken(JavadocParser.NEWLINE, i); 2238 } 2239 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2240 public TerminalNode LEADING_ASTERISK(int i) { 2241 return getToken(JavadocParser.LEADING_ASTERISK, i); 2242 } 2243 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2244 public TerminalNode WS(int i) { 2245 return getToken(JavadocParser.WS, i); 2246 } 2247 public LiTagCloseContext(ParserRuleContext parent, int invokingState) { 2248 super(parent, invokingState); 2249 } 2250 @Override public int getRuleIndex() { return RULE_liTagClose; } 2251 @Override 2252 public void enterRule(ParseTreeListener listener) { 2253 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagClose(this); 2254 } 2255 @Override 2256 public void exitRule(ParseTreeListener listener) { 2257 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagClose(this); 2258 } 2259 @Override 2260 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2261 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagClose(this); 2262 else return visitor.visitChildren(this); 2263 } 2264 } 2265 2266 public final LiTagCloseContext liTagClose() throws RecognitionException { 2267 LiTagCloseContext _localctx = new LiTagCloseContext(_ctx, getState()); 2268 enterRule(_localctx, 20, RULE_liTagClose); 2269 int _la; 2270 try { 2271 enterOuterAlt(_localctx, 1); 2272 { 2273 setState(388); 2274 match(OPEN); 2275 setState(389); 2276 match(SLASH); 2277 setState(390); 2278 match(LI_HTML_TAG_NAME); 2279 setState(394); 2280 _errHandler.sync(this); 2281 _la = _input.LA(1); 2282 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2283 { 2284 { 2285 setState(391); 2286 _la = _input.LA(1); 2287 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2288 _errHandler.recoverInline(this); 2289 } else { 2290 consume(); 2291 } 2292 } 2293 } 2294 setState(396); 2295 _errHandler.sync(this); 2296 _la = _input.LA(1); 2297 } 2298 setState(397); 2299 match(CLOSE); 2300 } 2301 } 2302 catch (RecognitionException re) { 2303 _localctx.exception = re; 2304 _errHandler.reportError(this, re); 2305 _errHandler.recover(this, re); 2306 } 2307 finally { 2308 exitRule(); 2309 } 2310 return _localctx; 2311 } 2312 2313 public static class LiContext extends ParserRuleContext { 2314 public LiTagOpenContext liTagOpen() { 2315 return getRuleContext(LiTagOpenContext.class,0); 2316 } 2317 public LiTagCloseContext liTagClose() { 2318 return getRuleContext(LiTagCloseContext.class,0); 2319 } 2320 public List<HtmlTagContext> htmlTag() { 2321 return getRuleContexts(HtmlTagContext.class); 2322 } 2323 public HtmlTagContext htmlTag(int i) { 2324 return getRuleContext(HtmlTagContext.class,i); 2325 } 2326 public List<SingletonTagContext> singletonTag() { 2327 return getRuleContexts(SingletonTagContext.class); 2328 } 2329 public SingletonTagContext singletonTag(int i) { 2330 return getRuleContext(SingletonTagContext.class,i); 2331 } 2332 public List<ParagraphContext> paragraph() { 2333 return getRuleContexts(ParagraphContext.class); 2334 } 2335 public ParagraphContext paragraph(int i) { 2336 return getRuleContext(ParagraphContext.class,i); 2337 } 2338 public List<TrContext> tr() { 2339 return getRuleContexts(TrContext.class); 2340 } 2341 public TrContext tr(int i) { 2342 return getRuleContext(TrContext.class,i); 2343 } 2344 public List<TdContext> td() { 2345 return getRuleContexts(TdContext.class); 2346 } 2347 public TdContext td(int i) { 2348 return getRuleContext(TdContext.class,i); 2349 } 2350 public List<ThContext> th() { 2351 return getRuleContexts(ThContext.class); 2352 } 2353 public ThContext th(int i) { 2354 return getRuleContext(ThContext.class,i); 2355 } 2356 public List<BodyContext> body() { 2357 return getRuleContexts(BodyContext.class); 2358 } 2359 public BodyContext body(int i) { 2360 return getRuleContext(BodyContext.class,i); 2361 } 2362 public List<ColgroupContext> colgroup() { 2363 return getRuleContexts(ColgroupContext.class); 2364 } 2365 public ColgroupContext colgroup(int i) { 2366 return getRuleContext(ColgroupContext.class,i); 2367 } 2368 public List<DdContext> dd() { 2369 return getRuleContexts(DdContext.class); 2370 } 2371 public DdContext dd(int i) { 2372 return getRuleContext(DdContext.class,i); 2373 } 2374 public List<DtContext> dt() { 2375 return getRuleContexts(DtContext.class); 2376 } 2377 public DtContext dt(int i) { 2378 return getRuleContext(DtContext.class,i); 2379 } 2380 public List<HeadContext> head() { 2381 return getRuleContexts(HeadContext.class); 2382 } 2383 public HeadContext head(int i) { 2384 return getRuleContext(HeadContext.class,i); 2385 } 2386 public List<HtmlContext> html() { 2387 return getRuleContexts(HtmlContext.class); 2388 } 2389 public HtmlContext html(int i) { 2390 return getRuleContext(HtmlContext.class,i); 2391 } 2392 public List<OptionContext> option() { 2393 return getRuleContexts(OptionContext.class); 2394 } 2395 public OptionContext option(int i) { 2396 return getRuleContext(OptionContext.class,i); 2397 } 2398 public List<TbodyContext> tbody() { 2399 return getRuleContexts(TbodyContext.class); 2400 } 2401 public TbodyContext tbody(int i) { 2402 return getRuleContext(TbodyContext.class,i); 2403 } 2404 public List<TheadContext> thead() { 2405 return getRuleContexts(TheadContext.class); 2406 } 2407 public TheadContext thead(int i) { 2408 return getRuleContext(TheadContext.class,i); 2409 } 2410 public List<TfootContext> tfoot() { 2411 return getRuleContexts(TfootContext.class); 2412 } 2413 public TfootContext tfoot(int i) { 2414 return getRuleContext(TfootContext.class,i); 2415 } 2416 public List<PTagOpenContext> pTagOpen() { 2417 return getRuleContexts(PTagOpenContext.class); 2418 } 2419 public PTagOpenContext pTagOpen(int i) { 2420 return getRuleContext(PTagOpenContext.class,i); 2421 } 2422 public List<TrTagOpenContext> trTagOpen() { 2423 return getRuleContexts(TrTagOpenContext.class); 2424 } 2425 public TrTagOpenContext trTagOpen(int i) { 2426 return getRuleContext(TrTagOpenContext.class,i); 2427 } 2428 public List<TdTagOpenContext> tdTagOpen() { 2429 return getRuleContexts(TdTagOpenContext.class); 2430 } 2431 public TdTagOpenContext tdTagOpen(int i) { 2432 return getRuleContext(TdTagOpenContext.class,i); 2433 } 2434 public List<ThTagOpenContext> thTagOpen() { 2435 return getRuleContexts(ThTagOpenContext.class); 2436 } 2437 public ThTagOpenContext thTagOpen(int i) { 2438 return getRuleContext(ThTagOpenContext.class,i); 2439 } 2440 public List<BodyTagOpenContext> bodyTagOpen() { 2441 return getRuleContexts(BodyTagOpenContext.class); 2442 } 2443 public BodyTagOpenContext bodyTagOpen(int i) { 2444 return getRuleContext(BodyTagOpenContext.class,i); 2445 } 2446 public List<ColgroupTagOpenContext> colgroupTagOpen() { 2447 return getRuleContexts(ColgroupTagOpenContext.class); 2448 } 2449 public ColgroupTagOpenContext colgroupTagOpen(int i) { 2450 return getRuleContext(ColgroupTagOpenContext.class,i); 2451 } 2452 public List<DdTagOpenContext> ddTagOpen() { 2453 return getRuleContexts(DdTagOpenContext.class); 2454 } 2455 public DdTagOpenContext ddTagOpen(int i) { 2456 return getRuleContext(DdTagOpenContext.class,i); 2457 } 2458 public List<DtTagOpenContext> dtTagOpen() { 2459 return getRuleContexts(DtTagOpenContext.class); 2460 } 2461 public DtTagOpenContext dtTagOpen(int i) { 2462 return getRuleContext(DtTagOpenContext.class,i); 2463 } 2464 public List<HeadTagOpenContext> headTagOpen() { 2465 return getRuleContexts(HeadTagOpenContext.class); 2466 } 2467 public HeadTagOpenContext headTagOpen(int i) { 2468 return getRuleContext(HeadTagOpenContext.class,i); 2469 } 2470 public List<HtmlTagOpenContext> htmlTagOpen() { 2471 return getRuleContexts(HtmlTagOpenContext.class); 2472 } 2473 public HtmlTagOpenContext htmlTagOpen(int i) { 2474 return getRuleContext(HtmlTagOpenContext.class,i); 2475 } 2476 public List<OptionTagOpenContext> optionTagOpen() { 2477 return getRuleContexts(OptionTagOpenContext.class); 2478 } 2479 public OptionTagOpenContext optionTagOpen(int i) { 2480 return getRuleContext(OptionTagOpenContext.class,i); 2481 } 2482 public List<TbodyTagOpenContext> tbodyTagOpen() { 2483 return getRuleContexts(TbodyTagOpenContext.class); 2484 } 2485 public TbodyTagOpenContext tbodyTagOpen(int i) { 2486 return getRuleContext(TbodyTagOpenContext.class,i); 2487 } 2488 public List<TheadTagOpenContext> theadTagOpen() { 2489 return getRuleContexts(TheadTagOpenContext.class); 2490 } 2491 public TheadTagOpenContext theadTagOpen(int i) { 2492 return getRuleContext(TheadTagOpenContext.class,i); 2493 } 2494 public List<TfootTagOpenContext> tfootTagOpen() { 2495 return getRuleContexts(TfootTagOpenContext.class); 2496 } 2497 public TfootTagOpenContext tfootTagOpen(int i) { 2498 return getRuleContext(TfootTagOpenContext.class,i); 2499 } 2500 public List<HtmlCommentContext> htmlComment() { 2501 return getRuleContexts(HtmlCommentContext.class); 2502 } 2503 public HtmlCommentContext htmlComment(int i) { 2504 return getRuleContext(HtmlCommentContext.class,i); 2505 } 2506 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 2507 public TerminalNode CDATA(int i) { 2508 return getToken(JavadocParser.CDATA, i); 2509 } 2510 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2511 public TerminalNode NEWLINE(int i) { 2512 return getToken(JavadocParser.NEWLINE, i); 2513 } 2514 public List<TextContext> text() { 2515 return getRuleContexts(TextContext.class); 2516 } 2517 public TextContext text(int i) { 2518 return getRuleContext(TextContext.class,i); 2519 } 2520 public List<JavadocInlineTagContext> javadocInlineTag() { 2521 return getRuleContexts(JavadocInlineTagContext.class); 2522 } 2523 public JavadocInlineTagContext javadocInlineTag(int i) { 2524 return getRuleContext(JavadocInlineTagContext.class,i); 2525 } 2526 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2527 public TerminalNode LEADING_ASTERISK(int i) { 2528 return getToken(JavadocParser.LEADING_ASTERISK, i); 2529 } 2530 public LiContext(ParserRuleContext parent, int invokingState) { 2531 super(parent, invokingState); 2532 } 2533 @Override public int getRuleIndex() { return RULE_li; } 2534 @Override 2535 public void enterRule(ParseTreeListener listener) { 2536 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLi(this); 2537 } 2538 @Override 2539 public void exitRule(ParseTreeListener listener) { 2540 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLi(this); 2541 } 2542 @Override 2543 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2544 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLi(this); 2545 else return visitor.visitChildren(this); 2546 } 2547 } 2548 2549 public final LiContext li() throws RecognitionException { 2550 LiContext _localctx = new LiContext(_ctx, getState()); 2551 enterRule(_localctx, 22, RULE_li); 2552 try { 2553 int _alt; 2554 enterOuterAlt(_localctx, 1); 2555 { 2556 setState(399); 2557 liTagOpen(); 2558 setState(439); 2559 _errHandler.sync(this); 2560 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 2561 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 2562 if ( _alt==1 ) { 2563 { 2564 setState(437); 2565 _errHandler.sync(this); 2566 switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) { 2567 case 1: 2568 { 2569 setState(400); 2570 htmlTag(); 2571 } 2572 break; 2573 case 2: 2574 { 2575 setState(401); 2576 singletonTag(); 2577 } 2578 break; 2579 case 3: 2580 { 2581 setState(402); 2582 paragraph(); 2583 } 2584 break; 2585 case 4: 2586 { 2587 setState(403); 2588 tr(); 2589 } 2590 break; 2591 case 5: 2592 { 2593 setState(404); 2594 td(); 2595 } 2596 break; 2597 case 6: 2598 { 2599 setState(405); 2600 th(); 2601 } 2602 break; 2603 case 7: 2604 { 2605 setState(406); 2606 body(); 2607 } 2608 break; 2609 case 8: 2610 { 2611 setState(407); 2612 colgroup(); 2613 } 2614 break; 2615 case 9: 2616 { 2617 setState(408); 2618 dd(); 2619 } 2620 break; 2621 case 10: 2622 { 2623 setState(409); 2624 dt(); 2625 } 2626 break; 2627 case 11: 2628 { 2629 setState(410); 2630 head(); 2631 } 2632 break; 2633 case 12: 2634 { 2635 setState(411); 2636 html(); 2637 } 2638 break; 2639 case 13: 2640 { 2641 setState(412); 2642 option(); 2643 } 2644 break; 2645 case 14: 2646 { 2647 setState(413); 2648 tbody(); 2649 } 2650 break; 2651 case 15: 2652 { 2653 setState(414); 2654 thead(); 2655 } 2656 break; 2657 case 16: 2658 { 2659 setState(415); 2660 tfoot(); 2661 } 2662 break; 2663 case 17: 2664 { 2665 setState(416); 2666 pTagOpen(); 2667 } 2668 break; 2669 case 18: 2670 { 2671 setState(417); 2672 trTagOpen(); 2673 } 2674 break; 2675 case 19: 2676 { 2677 setState(418); 2678 tdTagOpen(); 2679 } 2680 break; 2681 case 20: 2682 { 2683 setState(419); 2684 thTagOpen(); 2685 } 2686 break; 2687 case 21: 2688 { 2689 setState(420); 2690 bodyTagOpen(); 2691 } 2692 break; 2693 case 22: 2694 { 2695 setState(421); 2696 colgroupTagOpen(); 2697 } 2698 break; 2699 case 23: 2700 { 2701 setState(422); 2702 ddTagOpen(); 2703 } 2704 break; 2705 case 24: 2706 { 2707 setState(423); 2708 dtTagOpen(); 2709 } 2710 break; 2711 case 25: 2712 { 2713 setState(424); 2714 headTagOpen(); 2715 } 2716 break; 2717 case 26: 2718 { 2719 setState(425); 2720 htmlTagOpen(); 2721 } 2722 break; 2723 case 27: 2724 { 2725 setState(426); 2726 optionTagOpen(); 2727 } 2728 break; 2729 case 28: 2730 { 2731 setState(427); 2732 tbodyTagOpen(); 2733 } 2734 break; 2735 case 29: 2736 { 2737 setState(428); 2738 theadTagOpen(); 2739 } 2740 break; 2741 case 30: 2742 { 2743 setState(429); 2744 tfootTagOpen(); 2745 } 2746 break; 2747 case 31: 2748 { 2749 { 2750 setState(430); 2751 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2752 setState(431); 2753 match(LEADING_ASTERISK); 2754 } 2755 } 2756 break; 2757 case 32: 2758 { 2759 setState(432); 2760 htmlComment(); 2761 } 2762 break; 2763 case 33: 2764 { 2765 setState(433); 2766 match(CDATA); 2767 } 2768 break; 2769 case 34: 2770 { 2771 setState(434); 2772 match(NEWLINE); 2773 } 2774 break; 2775 case 35: 2776 { 2777 setState(435); 2778 text(); 2779 } 2780 break; 2781 case 36: 2782 { 2783 setState(436); 2784 javadocInlineTag(); 2785 } 2786 break; 2787 } 2788 } 2789 } 2790 setState(441); 2791 _errHandler.sync(this); 2792 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 2793 } 2794 setState(442); 2795 liTagClose(); 2796 } 2797 } 2798 catch (RecognitionException re) { 2799 _localctx.exception = re; 2800 _errHandler.reportError(this, re); 2801 _errHandler.recover(this, re); 2802 } 2803 finally { 2804 exitRule(); 2805 } 2806 return _localctx; 2807 } 2808 2809 public static class TrTagOpenContext extends ParserRuleContext { 2810 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2811 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2812 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2813 public List<AttributeContext> attribute() { 2814 return getRuleContexts(AttributeContext.class); 2815 } 2816 public AttributeContext attribute(int i) { 2817 return getRuleContext(AttributeContext.class,i); 2818 } 2819 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2820 public TerminalNode NEWLINE(int i) { 2821 return getToken(JavadocParser.NEWLINE, i); 2822 } 2823 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2824 public TerminalNode LEADING_ASTERISK(int i) { 2825 return getToken(JavadocParser.LEADING_ASTERISK, i); 2826 } 2827 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2828 public TerminalNode WS(int i) { 2829 return getToken(JavadocParser.WS, i); 2830 } 2831 public TrTagOpenContext(ParserRuleContext parent, int invokingState) { 2832 super(parent, invokingState); 2833 } 2834 @Override public int getRuleIndex() { return RULE_trTagOpen; } 2835 @Override 2836 public void enterRule(ParseTreeListener listener) { 2837 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagOpen(this); 2838 } 2839 @Override 2840 public void exitRule(ParseTreeListener listener) { 2841 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagOpen(this); 2842 } 2843 @Override 2844 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2845 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagOpen(this); 2846 else return visitor.visitChildren(this); 2847 } 2848 } 2849 2850 public final TrTagOpenContext trTagOpen() throws RecognitionException { 2851 TrTagOpenContext _localctx = new TrTagOpenContext(_ctx, getState()); 2852 enterRule(_localctx, 24, RULE_trTagOpen); 2853 int _la; 2854 try { 2855 enterOuterAlt(_localctx, 1); 2856 { 2857 setState(444); 2858 match(OPEN); 2859 setState(445); 2860 match(TR_HTML_TAG_NAME); 2861 setState(452); 2862 _errHandler.sync(this); 2863 _la = _input.LA(1); 2864 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2865 { 2866 setState(450); 2867 switch (_input.LA(1)) { 2868 case HTML_TAG_NAME: 2869 { 2870 setState(446); 2871 attribute(); 2872 } 2873 break; 2874 case NEWLINE: 2875 { 2876 setState(447); 2877 match(NEWLINE); 2878 } 2879 break; 2880 case LEADING_ASTERISK: 2881 { 2882 setState(448); 2883 match(LEADING_ASTERISK); 2884 } 2885 break; 2886 case WS: 2887 { 2888 setState(449); 2889 match(WS); 2890 } 2891 break; 2892 default: 2893 throw new NoViableAltException(this); 2894 } 2895 } 2896 setState(454); 2897 _errHandler.sync(this); 2898 _la = _input.LA(1); 2899 } 2900 setState(455); 2901 match(CLOSE); 2902 } 2903 } 2904 catch (RecognitionException re) { 2905 _localctx.exception = re; 2906 _errHandler.reportError(this, re); 2907 _errHandler.recover(this, re); 2908 } 2909 finally { 2910 exitRule(); 2911 } 2912 return _localctx; 2913 } 2914 2915 public static class TrTagCloseContext extends ParserRuleContext { 2916 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2917 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2918 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2919 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2920 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2921 public TerminalNode NEWLINE(int i) { 2922 return getToken(JavadocParser.NEWLINE, i); 2923 } 2924 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2925 public TerminalNode LEADING_ASTERISK(int i) { 2926 return getToken(JavadocParser.LEADING_ASTERISK, i); 2927 } 2928 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2929 public TerminalNode WS(int i) { 2930 return getToken(JavadocParser.WS, i); 2931 } 2932 public TrTagCloseContext(ParserRuleContext parent, int invokingState) { 2933 super(parent, invokingState); 2934 } 2935 @Override public int getRuleIndex() { return RULE_trTagClose; } 2936 @Override 2937 public void enterRule(ParseTreeListener listener) { 2938 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagClose(this); 2939 } 2940 @Override 2941 public void exitRule(ParseTreeListener listener) { 2942 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagClose(this); 2943 } 2944 @Override 2945 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2946 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagClose(this); 2947 else return visitor.visitChildren(this); 2948 } 2949 } 2950 2951 public final TrTagCloseContext trTagClose() throws RecognitionException { 2952 TrTagCloseContext _localctx = new TrTagCloseContext(_ctx, getState()); 2953 enterRule(_localctx, 26, RULE_trTagClose); 2954 int _la; 2955 try { 2956 enterOuterAlt(_localctx, 1); 2957 { 2958 setState(457); 2959 match(OPEN); 2960 setState(458); 2961 match(SLASH); 2962 setState(459); 2963 match(TR_HTML_TAG_NAME); 2964 setState(463); 2965 _errHandler.sync(this); 2966 _la = _input.LA(1); 2967 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2968 { 2969 { 2970 setState(460); 2971 _la = _input.LA(1); 2972 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2973 _errHandler.recoverInline(this); 2974 } else { 2975 consume(); 2976 } 2977 } 2978 } 2979 setState(465); 2980 _errHandler.sync(this); 2981 _la = _input.LA(1); 2982 } 2983 setState(466); 2984 match(CLOSE); 2985 } 2986 } 2987 catch (RecognitionException re) { 2988 _localctx.exception = re; 2989 _errHandler.reportError(this, re); 2990 _errHandler.recover(this, re); 2991 } 2992 finally { 2993 exitRule(); 2994 } 2995 return _localctx; 2996 } 2997 2998 public static class TrContext extends ParserRuleContext { 2999 public TrTagOpenContext trTagOpen() { 3000 return getRuleContext(TrTagOpenContext.class,0); 3001 } 3002 public TrTagCloseContext trTagClose() { 3003 return getRuleContext(TrTagCloseContext.class,0); 3004 } 3005 public List<HtmlTagContext> htmlTag() { 3006 return getRuleContexts(HtmlTagContext.class); 3007 } 3008 public HtmlTagContext htmlTag(int i) { 3009 return getRuleContext(HtmlTagContext.class,i); 3010 } 3011 public List<SingletonTagContext> singletonTag() { 3012 return getRuleContexts(SingletonTagContext.class); 3013 } 3014 public SingletonTagContext singletonTag(int i) { 3015 return getRuleContext(SingletonTagContext.class,i); 3016 } 3017 public List<ParagraphContext> paragraph() { 3018 return getRuleContexts(ParagraphContext.class); 3019 } 3020 public ParagraphContext paragraph(int i) { 3021 return getRuleContext(ParagraphContext.class,i); 3022 } 3023 public List<LiContext> li() { 3024 return getRuleContexts(LiContext.class); 3025 } 3026 public LiContext li(int i) { 3027 return getRuleContext(LiContext.class,i); 3028 } 3029 public List<TdContext> td() { 3030 return getRuleContexts(TdContext.class); 3031 } 3032 public TdContext td(int i) { 3033 return getRuleContext(TdContext.class,i); 3034 } 3035 public List<ThContext> th() { 3036 return getRuleContexts(ThContext.class); 3037 } 3038 public ThContext th(int i) { 3039 return getRuleContext(ThContext.class,i); 3040 } 3041 public List<BodyContext> body() { 3042 return getRuleContexts(BodyContext.class); 3043 } 3044 public BodyContext body(int i) { 3045 return getRuleContext(BodyContext.class,i); 3046 } 3047 public List<ColgroupContext> colgroup() { 3048 return getRuleContexts(ColgroupContext.class); 3049 } 3050 public ColgroupContext colgroup(int i) { 3051 return getRuleContext(ColgroupContext.class,i); 3052 } 3053 public List<DdContext> dd() { 3054 return getRuleContexts(DdContext.class); 3055 } 3056 public DdContext dd(int i) { 3057 return getRuleContext(DdContext.class,i); 3058 } 3059 public List<DtContext> dt() { 3060 return getRuleContexts(DtContext.class); 3061 } 3062 public DtContext dt(int i) { 3063 return getRuleContext(DtContext.class,i); 3064 } 3065 public List<HeadContext> head() { 3066 return getRuleContexts(HeadContext.class); 3067 } 3068 public HeadContext head(int i) { 3069 return getRuleContext(HeadContext.class,i); 3070 } 3071 public List<HtmlContext> html() { 3072 return getRuleContexts(HtmlContext.class); 3073 } 3074 public HtmlContext html(int i) { 3075 return getRuleContext(HtmlContext.class,i); 3076 } 3077 public List<OptionContext> option() { 3078 return getRuleContexts(OptionContext.class); 3079 } 3080 public OptionContext option(int i) { 3081 return getRuleContext(OptionContext.class,i); 3082 } 3083 public List<TbodyContext> tbody() { 3084 return getRuleContexts(TbodyContext.class); 3085 } 3086 public TbodyContext tbody(int i) { 3087 return getRuleContext(TbodyContext.class,i); 3088 } 3089 public List<TheadContext> thead() { 3090 return getRuleContexts(TheadContext.class); 3091 } 3092 public TheadContext thead(int i) { 3093 return getRuleContext(TheadContext.class,i); 3094 } 3095 public List<TfootContext> tfoot() { 3096 return getRuleContexts(TfootContext.class); 3097 } 3098 public TfootContext tfoot(int i) { 3099 return getRuleContext(TfootContext.class,i); 3100 } 3101 public List<PTagOpenContext> pTagOpen() { 3102 return getRuleContexts(PTagOpenContext.class); 3103 } 3104 public PTagOpenContext pTagOpen(int i) { 3105 return getRuleContext(PTagOpenContext.class,i); 3106 } 3107 public List<LiTagOpenContext> liTagOpen() { 3108 return getRuleContexts(LiTagOpenContext.class); 3109 } 3110 public LiTagOpenContext liTagOpen(int i) { 3111 return getRuleContext(LiTagOpenContext.class,i); 3112 } 3113 public List<TdTagOpenContext> tdTagOpen() { 3114 return getRuleContexts(TdTagOpenContext.class); 3115 } 3116 public TdTagOpenContext tdTagOpen(int i) { 3117 return getRuleContext(TdTagOpenContext.class,i); 3118 } 3119 public List<ThTagOpenContext> thTagOpen() { 3120 return getRuleContexts(ThTagOpenContext.class); 3121 } 3122 public ThTagOpenContext thTagOpen(int i) { 3123 return getRuleContext(ThTagOpenContext.class,i); 3124 } 3125 public List<BodyTagOpenContext> bodyTagOpen() { 3126 return getRuleContexts(BodyTagOpenContext.class); 3127 } 3128 public BodyTagOpenContext bodyTagOpen(int i) { 3129 return getRuleContext(BodyTagOpenContext.class,i); 3130 } 3131 public List<ColgroupTagOpenContext> colgroupTagOpen() { 3132 return getRuleContexts(ColgroupTagOpenContext.class); 3133 } 3134 public ColgroupTagOpenContext colgroupTagOpen(int i) { 3135 return getRuleContext(ColgroupTagOpenContext.class,i); 3136 } 3137 public List<DdTagOpenContext> ddTagOpen() { 3138 return getRuleContexts(DdTagOpenContext.class); 3139 } 3140 public DdTagOpenContext ddTagOpen(int i) { 3141 return getRuleContext(DdTagOpenContext.class,i); 3142 } 3143 public List<DtTagOpenContext> dtTagOpen() { 3144 return getRuleContexts(DtTagOpenContext.class); 3145 } 3146 public DtTagOpenContext dtTagOpen(int i) { 3147 return getRuleContext(DtTagOpenContext.class,i); 3148 } 3149 public List<HeadTagOpenContext> headTagOpen() { 3150 return getRuleContexts(HeadTagOpenContext.class); 3151 } 3152 public HeadTagOpenContext headTagOpen(int i) { 3153 return getRuleContext(HeadTagOpenContext.class,i); 3154 } 3155 public List<HtmlTagOpenContext> htmlTagOpen() { 3156 return getRuleContexts(HtmlTagOpenContext.class); 3157 } 3158 public HtmlTagOpenContext htmlTagOpen(int i) { 3159 return getRuleContext(HtmlTagOpenContext.class,i); 3160 } 3161 public List<OptionTagOpenContext> optionTagOpen() { 3162 return getRuleContexts(OptionTagOpenContext.class); 3163 } 3164 public OptionTagOpenContext optionTagOpen(int i) { 3165 return getRuleContext(OptionTagOpenContext.class,i); 3166 } 3167 public List<TbodyTagOpenContext> tbodyTagOpen() { 3168 return getRuleContexts(TbodyTagOpenContext.class); 3169 } 3170 public TbodyTagOpenContext tbodyTagOpen(int i) { 3171 return getRuleContext(TbodyTagOpenContext.class,i); 3172 } 3173 public List<TheadTagOpenContext> theadTagOpen() { 3174 return getRuleContexts(TheadTagOpenContext.class); 3175 } 3176 public TheadTagOpenContext theadTagOpen(int i) { 3177 return getRuleContext(TheadTagOpenContext.class,i); 3178 } 3179 public List<TfootTagOpenContext> tfootTagOpen() { 3180 return getRuleContexts(TfootTagOpenContext.class); 3181 } 3182 public TfootTagOpenContext tfootTagOpen(int i) { 3183 return getRuleContext(TfootTagOpenContext.class,i); 3184 } 3185 public List<HtmlCommentContext> htmlComment() { 3186 return getRuleContexts(HtmlCommentContext.class); 3187 } 3188 public HtmlCommentContext htmlComment(int i) { 3189 return getRuleContext(HtmlCommentContext.class,i); 3190 } 3191 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3192 public TerminalNode CDATA(int i) { 3193 return getToken(JavadocParser.CDATA, i); 3194 } 3195 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3196 public TerminalNode NEWLINE(int i) { 3197 return getToken(JavadocParser.NEWLINE, i); 3198 } 3199 public List<TextContext> text() { 3200 return getRuleContexts(TextContext.class); 3201 } 3202 public TextContext text(int i) { 3203 return getRuleContext(TextContext.class,i); 3204 } 3205 public List<JavadocInlineTagContext> javadocInlineTag() { 3206 return getRuleContexts(JavadocInlineTagContext.class); 3207 } 3208 public JavadocInlineTagContext javadocInlineTag(int i) { 3209 return getRuleContext(JavadocInlineTagContext.class,i); 3210 } 3211 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3212 public TerminalNode LEADING_ASTERISK(int i) { 3213 return getToken(JavadocParser.LEADING_ASTERISK, i); 3214 } 3215 public TrContext(ParserRuleContext parent, int invokingState) { 3216 super(parent, invokingState); 3217 } 3218 @Override public int getRuleIndex() { return RULE_tr; } 3219 @Override 3220 public void enterRule(ParseTreeListener listener) { 3221 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTr(this); 3222 } 3223 @Override 3224 public void exitRule(ParseTreeListener listener) { 3225 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTr(this); 3226 } 3227 @Override 3228 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3229 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTr(this); 3230 else return visitor.visitChildren(this); 3231 } 3232 } 3233 3234 public final TrContext tr() throws RecognitionException { 3235 TrContext _localctx = new TrContext(_ctx, getState()); 3236 enterRule(_localctx, 28, RULE_tr); 3237 try { 3238 int _alt; 3239 enterOuterAlt(_localctx, 1); 3240 { 3241 setState(468); 3242 trTagOpen(); 3243 setState(508); 3244 _errHandler.sync(this); 3245 _alt = getInterpreter().adaptivePredict(_input,31,_ctx); 3246 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3247 if ( _alt==1 ) { 3248 { 3249 setState(506); 3250 _errHandler.sync(this); 3251 switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) { 3252 case 1: 3253 { 3254 setState(469); 3255 htmlTag(); 3256 } 3257 break; 3258 case 2: 3259 { 3260 setState(470); 3261 singletonTag(); 3262 } 3263 break; 3264 case 3: 3265 { 3266 setState(471); 3267 paragraph(); 3268 } 3269 break; 3270 case 4: 3271 { 3272 setState(472); 3273 li(); 3274 } 3275 break; 3276 case 5: 3277 { 3278 setState(473); 3279 td(); 3280 } 3281 break; 3282 case 6: 3283 { 3284 setState(474); 3285 th(); 3286 } 3287 break; 3288 case 7: 3289 { 3290 setState(475); 3291 body(); 3292 } 3293 break; 3294 case 8: 3295 { 3296 setState(476); 3297 colgroup(); 3298 } 3299 break; 3300 case 9: 3301 { 3302 setState(477); 3303 dd(); 3304 } 3305 break; 3306 case 10: 3307 { 3308 setState(478); 3309 dt(); 3310 } 3311 break; 3312 case 11: 3313 { 3314 setState(479); 3315 head(); 3316 } 3317 break; 3318 case 12: 3319 { 3320 setState(480); 3321 html(); 3322 } 3323 break; 3324 case 13: 3325 { 3326 setState(481); 3327 option(); 3328 } 3329 break; 3330 case 14: 3331 { 3332 setState(482); 3333 tbody(); 3334 } 3335 break; 3336 case 15: 3337 { 3338 setState(483); 3339 thead(); 3340 } 3341 break; 3342 case 16: 3343 { 3344 setState(484); 3345 tfoot(); 3346 } 3347 break; 3348 case 17: 3349 { 3350 setState(485); 3351 pTagOpen(); 3352 } 3353 break; 3354 case 18: 3355 { 3356 setState(486); 3357 liTagOpen(); 3358 } 3359 break; 3360 case 19: 3361 { 3362 setState(487); 3363 tdTagOpen(); 3364 } 3365 break; 3366 case 20: 3367 { 3368 setState(488); 3369 thTagOpen(); 3370 } 3371 break; 3372 case 21: 3373 { 3374 setState(489); 3375 bodyTagOpen(); 3376 } 3377 break; 3378 case 22: 3379 { 3380 setState(490); 3381 colgroupTagOpen(); 3382 } 3383 break; 3384 case 23: 3385 { 3386 setState(491); 3387 ddTagOpen(); 3388 } 3389 break; 3390 case 24: 3391 { 3392 setState(492); 3393 dtTagOpen(); 3394 } 3395 break; 3396 case 25: 3397 { 3398 setState(493); 3399 headTagOpen(); 3400 } 3401 break; 3402 case 26: 3403 { 3404 setState(494); 3405 htmlTagOpen(); 3406 } 3407 break; 3408 case 27: 3409 { 3410 setState(495); 3411 optionTagOpen(); 3412 } 3413 break; 3414 case 28: 3415 { 3416 setState(496); 3417 tbodyTagOpen(); 3418 } 3419 break; 3420 case 29: 3421 { 3422 setState(497); 3423 theadTagOpen(); 3424 } 3425 break; 3426 case 30: 3427 { 3428 setState(498); 3429 tfootTagOpen(); 3430 } 3431 break; 3432 case 31: 3433 { 3434 { 3435 setState(499); 3436 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 3437 setState(500); 3438 match(LEADING_ASTERISK); 3439 } 3440 } 3441 break; 3442 case 32: 3443 { 3444 setState(501); 3445 htmlComment(); 3446 } 3447 break; 3448 case 33: 3449 { 3450 setState(502); 3451 match(CDATA); 3452 } 3453 break; 3454 case 34: 3455 { 3456 setState(503); 3457 match(NEWLINE); 3458 } 3459 break; 3460 case 35: 3461 { 3462 setState(504); 3463 text(); 3464 } 3465 break; 3466 case 36: 3467 { 3468 setState(505); 3469 javadocInlineTag(); 3470 } 3471 break; 3472 } 3473 } 3474 } 3475 setState(510); 3476 _errHandler.sync(this); 3477 _alt = getInterpreter().adaptivePredict(_input,31,_ctx); 3478 } 3479 setState(511); 3480 trTagClose(); 3481 } 3482 } 3483 catch (RecognitionException re) { 3484 _localctx.exception = re; 3485 _errHandler.reportError(this, re); 3486 _errHandler.recover(this, re); 3487 } 3488 finally { 3489 exitRule(); 3490 } 3491 return _localctx; 3492 } 3493 3494 public static class TdTagOpenContext extends ParserRuleContext { 3495 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 3496 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3497 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 3498 public List<AttributeContext> attribute() { 3499 return getRuleContexts(AttributeContext.class); 3500 } 3501 public AttributeContext attribute(int i) { 3502 return getRuleContext(AttributeContext.class,i); 3503 } 3504 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3505 public TerminalNode NEWLINE(int i) { 3506 return getToken(JavadocParser.NEWLINE, i); 3507 } 3508 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3509 public TerminalNode LEADING_ASTERISK(int i) { 3510 return getToken(JavadocParser.LEADING_ASTERISK, i); 3511 } 3512 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3513 public TerminalNode WS(int i) { 3514 return getToken(JavadocParser.WS, i); 3515 } 3516 public TdTagOpenContext(ParserRuleContext parent, int invokingState) { 3517 super(parent, invokingState); 3518 } 3519 @Override public int getRuleIndex() { return RULE_tdTagOpen; } 3520 @Override 3521 public void enterRule(ParseTreeListener listener) { 3522 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagOpen(this); 3523 } 3524 @Override 3525 public void exitRule(ParseTreeListener listener) { 3526 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagOpen(this); 3527 } 3528 @Override 3529 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3530 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagOpen(this); 3531 else return visitor.visitChildren(this); 3532 } 3533 } 3534 3535 public final TdTagOpenContext tdTagOpen() throws RecognitionException { 3536 TdTagOpenContext _localctx = new TdTagOpenContext(_ctx, getState()); 3537 enterRule(_localctx, 30, RULE_tdTagOpen); 3538 int _la; 3539 try { 3540 enterOuterAlt(_localctx, 1); 3541 { 3542 setState(513); 3543 match(OPEN); 3544 setState(514); 3545 match(TD_HTML_TAG_NAME); 3546 setState(521); 3547 _errHandler.sync(this); 3548 _la = _input.LA(1); 3549 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 3550 { 3551 setState(519); 3552 switch (_input.LA(1)) { 3553 case HTML_TAG_NAME: 3554 { 3555 setState(515); 3556 attribute(); 3557 } 3558 break; 3559 case NEWLINE: 3560 { 3561 setState(516); 3562 match(NEWLINE); 3563 } 3564 break; 3565 case LEADING_ASTERISK: 3566 { 3567 setState(517); 3568 match(LEADING_ASTERISK); 3569 } 3570 break; 3571 case WS: 3572 { 3573 setState(518); 3574 match(WS); 3575 } 3576 break; 3577 default: 3578 throw new NoViableAltException(this); 3579 } 3580 } 3581 setState(523); 3582 _errHandler.sync(this); 3583 _la = _input.LA(1); 3584 } 3585 setState(524); 3586 match(CLOSE); 3587 } 3588 } 3589 catch (RecognitionException re) { 3590 _localctx.exception = re; 3591 _errHandler.reportError(this, re); 3592 _errHandler.recover(this, re); 3593 } 3594 finally { 3595 exitRule(); 3596 } 3597 return _localctx; 3598 } 3599 3600 public static class TdTagCloseContext extends ParserRuleContext { 3601 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 3602 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 3603 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3604 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 3605 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3606 public TerminalNode NEWLINE(int i) { 3607 return getToken(JavadocParser.NEWLINE, i); 3608 } 3609 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3610 public TerminalNode LEADING_ASTERISK(int i) { 3611 return getToken(JavadocParser.LEADING_ASTERISK, i); 3612 } 3613 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3614 public TerminalNode WS(int i) { 3615 return getToken(JavadocParser.WS, i); 3616 } 3617 public TdTagCloseContext(ParserRuleContext parent, int invokingState) { 3618 super(parent, invokingState); 3619 } 3620 @Override public int getRuleIndex() { return RULE_tdTagClose; } 3621 @Override 3622 public void enterRule(ParseTreeListener listener) { 3623 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagClose(this); 3624 } 3625 @Override 3626 public void exitRule(ParseTreeListener listener) { 3627 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagClose(this); 3628 } 3629 @Override 3630 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3631 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagClose(this); 3632 else return visitor.visitChildren(this); 3633 } 3634 } 3635 3636 public final TdTagCloseContext tdTagClose() throws RecognitionException { 3637 TdTagCloseContext _localctx = new TdTagCloseContext(_ctx, getState()); 3638 enterRule(_localctx, 32, RULE_tdTagClose); 3639 int _la; 3640 try { 3641 enterOuterAlt(_localctx, 1); 3642 { 3643 setState(526); 3644 match(OPEN); 3645 setState(527); 3646 match(SLASH); 3647 setState(528); 3648 match(TD_HTML_TAG_NAME); 3649 setState(532); 3650 _errHandler.sync(this); 3651 _la = _input.LA(1); 3652 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3653 { 3654 { 3655 setState(529); 3656 _la = _input.LA(1); 3657 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3658 _errHandler.recoverInline(this); 3659 } else { 3660 consume(); 3661 } 3662 } 3663 } 3664 setState(534); 3665 _errHandler.sync(this); 3666 _la = _input.LA(1); 3667 } 3668 setState(535); 3669 match(CLOSE); 3670 } 3671 } 3672 catch (RecognitionException re) { 3673 _localctx.exception = re; 3674 _errHandler.reportError(this, re); 3675 _errHandler.recover(this, re); 3676 } 3677 finally { 3678 exitRule(); 3679 } 3680 return _localctx; 3681 } 3682 3683 public static class TdContext extends ParserRuleContext { 3684 public List<TdTagOpenContext> tdTagOpen() { 3685 return getRuleContexts(TdTagOpenContext.class); 3686 } 3687 public TdTagOpenContext tdTagOpen(int i) { 3688 return getRuleContext(TdTagOpenContext.class,i); 3689 } 3690 public TdTagCloseContext tdTagClose() { 3691 return getRuleContext(TdTagCloseContext.class,0); 3692 } 3693 public List<HtmlTagContext> htmlTag() { 3694 return getRuleContexts(HtmlTagContext.class); 3695 } 3696 public HtmlTagContext htmlTag(int i) { 3697 return getRuleContext(HtmlTagContext.class,i); 3698 } 3699 public List<SingletonTagContext> singletonTag() { 3700 return getRuleContexts(SingletonTagContext.class); 3701 } 3702 public SingletonTagContext singletonTag(int i) { 3703 return getRuleContext(SingletonTagContext.class,i); 3704 } 3705 public List<ParagraphContext> paragraph() { 3706 return getRuleContexts(ParagraphContext.class); 3707 } 3708 public ParagraphContext paragraph(int i) { 3709 return getRuleContext(ParagraphContext.class,i); 3710 } 3711 public List<LiContext> li() { 3712 return getRuleContexts(LiContext.class); 3713 } 3714 public LiContext li(int i) { 3715 return getRuleContext(LiContext.class,i); 3716 } 3717 public List<TrContext> tr() { 3718 return getRuleContexts(TrContext.class); 3719 } 3720 public TrContext tr(int i) { 3721 return getRuleContext(TrContext.class,i); 3722 } 3723 public List<ThContext> th() { 3724 return getRuleContexts(ThContext.class); 3725 } 3726 public ThContext th(int i) { 3727 return getRuleContext(ThContext.class,i); 3728 } 3729 public List<BodyContext> body() { 3730 return getRuleContexts(BodyContext.class); 3731 } 3732 public BodyContext body(int i) { 3733 return getRuleContext(BodyContext.class,i); 3734 } 3735 public List<ColgroupContext> colgroup() { 3736 return getRuleContexts(ColgroupContext.class); 3737 } 3738 public ColgroupContext colgroup(int i) { 3739 return getRuleContext(ColgroupContext.class,i); 3740 } 3741 public List<DdContext> dd() { 3742 return getRuleContexts(DdContext.class); 3743 } 3744 public DdContext dd(int i) { 3745 return getRuleContext(DdContext.class,i); 3746 } 3747 public List<DtContext> dt() { 3748 return getRuleContexts(DtContext.class); 3749 } 3750 public DtContext dt(int i) { 3751 return getRuleContext(DtContext.class,i); 3752 } 3753 public List<HeadContext> head() { 3754 return getRuleContexts(HeadContext.class); 3755 } 3756 public HeadContext head(int i) { 3757 return getRuleContext(HeadContext.class,i); 3758 } 3759 public List<HtmlContext> html() { 3760 return getRuleContexts(HtmlContext.class); 3761 } 3762 public HtmlContext html(int i) { 3763 return getRuleContext(HtmlContext.class,i); 3764 } 3765 public List<OptionContext> option() { 3766 return getRuleContexts(OptionContext.class); 3767 } 3768 public OptionContext option(int i) { 3769 return getRuleContext(OptionContext.class,i); 3770 } 3771 public List<TbodyContext> tbody() { 3772 return getRuleContexts(TbodyContext.class); 3773 } 3774 public TbodyContext tbody(int i) { 3775 return getRuleContext(TbodyContext.class,i); 3776 } 3777 public List<TheadContext> thead() { 3778 return getRuleContexts(TheadContext.class); 3779 } 3780 public TheadContext thead(int i) { 3781 return getRuleContext(TheadContext.class,i); 3782 } 3783 public List<TfootContext> tfoot() { 3784 return getRuleContexts(TfootContext.class); 3785 } 3786 public TfootContext tfoot(int i) { 3787 return getRuleContext(TfootContext.class,i); 3788 } 3789 public List<PTagOpenContext> pTagOpen() { 3790 return getRuleContexts(PTagOpenContext.class); 3791 } 3792 public PTagOpenContext pTagOpen(int i) { 3793 return getRuleContext(PTagOpenContext.class,i); 3794 } 3795 public List<LiTagOpenContext> liTagOpen() { 3796 return getRuleContexts(LiTagOpenContext.class); 3797 } 3798 public LiTagOpenContext liTagOpen(int i) { 3799 return getRuleContext(LiTagOpenContext.class,i); 3800 } 3801 public List<ThTagOpenContext> thTagOpen() { 3802 return getRuleContexts(ThTagOpenContext.class); 3803 } 3804 public ThTagOpenContext thTagOpen(int i) { 3805 return getRuleContext(ThTagOpenContext.class,i); 3806 } 3807 public List<BodyTagOpenContext> bodyTagOpen() { 3808 return getRuleContexts(BodyTagOpenContext.class); 3809 } 3810 public BodyTagOpenContext bodyTagOpen(int i) { 3811 return getRuleContext(BodyTagOpenContext.class,i); 3812 } 3813 public List<ColgroupTagOpenContext> colgroupTagOpen() { 3814 return getRuleContexts(ColgroupTagOpenContext.class); 3815 } 3816 public ColgroupTagOpenContext colgroupTagOpen(int i) { 3817 return getRuleContext(ColgroupTagOpenContext.class,i); 3818 } 3819 public List<DdTagOpenContext> ddTagOpen() { 3820 return getRuleContexts(DdTagOpenContext.class); 3821 } 3822 public DdTagOpenContext ddTagOpen(int i) { 3823 return getRuleContext(DdTagOpenContext.class,i); 3824 } 3825 public List<DtTagOpenContext> dtTagOpen() { 3826 return getRuleContexts(DtTagOpenContext.class); 3827 } 3828 public DtTagOpenContext dtTagOpen(int i) { 3829 return getRuleContext(DtTagOpenContext.class,i); 3830 } 3831 public List<HeadTagOpenContext> headTagOpen() { 3832 return getRuleContexts(HeadTagOpenContext.class); 3833 } 3834 public HeadTagOpenContext headTagOpen(int i) { 3835 return getRuleContext(HeadTagOpenContext.class,i); 3836 } 3837 public List<HtmlTagOpenContext> htmlTagOpen() { 3838 return getRuleContexts(HtmlTagOpenContext.class); 3839 } 3840 public HtmlTagOpenContext htmlTagOpen(int i) { 3841 return getRuleContext(HtmlTagOpenContext.class,i); 3842 } 3843 public List<OptionTagOpenContext> optionTagOpen() { 3844 return getRuleContexts(OptionTagOpenContext.class); 3845 } 3846 public OptionTagOpenContext optionTagOpen(int i) { 3847 return getRuleContext(OptionTagOpenContext.class,i); 3848 } 3849 public List<TbodyTagOpenContext> tbodyTagOpen() { 3850 return getRuleContexts(TbodyTagOpenContext.class); 3851 } 3852 public TbodyTagOpenContext tbodyTagOpen(int i) { 3853 return getRuleContext(TbodyTagOpenContext.class,i); 3854 } 3855 public List<TheadTagOpenContext> theadTagOpen() { 3856 return getRuleContexts(TheadTagOpenContext.class); 3857 } 3858 public TheadTagOpenContext theadTagOpen(int i) { 3859 return getRuleContext(TheadTagOpenContext.class,i); 3860 } 3861 public List<TfootTagOpenContext> tfootTagOpen() { 3862 return getRuleContexts(TfootTagOpenContext.class); 3863 } 3864 public TfootTagOpenContext tfootTagOpen(int i) { 3865 return getRuleContext(TfootTagOpenContext.class,i); 3866 } 3867 public List<HtmlCommentContext> htmlComment() { 3868 return getRuleContexts(HtmlCommentContext.class); 3869 } 3870 public HtmlCommentContext htmlComment(int i) { 3871 return getRuleContext(HtmlCommentContext.class,i); 3872 } 3873 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3874 public TerminalNode CDATA(int i) { 3875 return getToken(JavadocParser.CDATA, i); 3876 } 3877 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3878 public TerminalNode NEWLINE(int i) { 3879 return getToken(JavadocParser.NEWLINE, i); 3880 } 3881 public List<TextContext> text() { 3882 return getRuleContexts(TextContext.class); 3883 } 3884 public TextContext text(int i) { 3885 return getRuleContext(TextContext.class,i); 3886 } 3887 public List<JavadocInlineTagContext> javadocInlineTag() { 3888 return getRuleContexts(JavadocInlineTagContext.class); 3889 } 3890 public JavadocInlineTagContext javadocInlineTag(int i) { 3891 return getRuleContext(JavadocInlineTagContext.class,i); 3892 } 3893 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3894 public TerminalNode LEADING_ASTERISK(int i) { 3895 return getToken(JavadocParser.LEADING_ASTERISK, i); 3896 } 3897 public TdContext(ParserRuleContext parent, int invokingState) { 3898 super(parent, invokingState); 3899 } 3900 @Override public int getRuleIndex() { return RULE_td; } 3901 @Override 3902 public void enterRule(ParseTreeListener listener) { 3903 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTd(this); 3904 } 3905 @Override 3906 public void exitRule(ParseTreeListener listener) { 3907 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTd(this); 3908 } 3909 @Override 3910 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3911 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTd(this); 3912 else return visitor.visitChildren(this); 3913 } 3914 } 3915 3916 public final TdContext td() throws RecognitionException { 3917 TdContext _localctx = new TdContext(_ctx, getState()); 3918 enterRule(_localctx, 34, RULE_td); 3919 try { 3920 int _alt; 3921 enterOuterAlt(_localctx, 1); 3922 { 3923 setState(537); 3924 tdTagOpen(); 3925 setState(577); 3926 _errHandler.sync(this); 3927 _alt = getInterpreter().adaptivePredict(_input,36,_ctx); 3928 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3929 if ( _alt==1 ) { 3930 { 3931 setState(575); 3932 _errHandler.sync(this); 3933 switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { 3934 case 1: 3935 { 3936 setState(538); 3937 htmlTag(); 3938 } 3939 break; 3940 case 2: 3941 { 3942 setState(539); 3943 singletonTag(); 3944 } 3945 break; 3946 case 3: 3947 { 3948 setState(540); 3949 paragraph(); 3950 } 3951 break; 3952 case 4: 3953 { 3954 setState(541); 3955 li(); 3956 } 3957 break; 3958 case 5: 3959 { 3960 setState(542); 3961 tr(); 3962 } 3963 break; 3964 case 6: 3965 { 3966 setState(543); 3967 th(); 3968 } 3969 break; 3970 case 7: 3971 { 3972 setState(544); 3973 body(); 3974 } 3975 break; 3976 case 8: 3977 { 3978 setState(545); 3979 colgroup(); 3980 } 3981 break; 3982 case 9: 3983 { 3984 setState(546); 3985 dd(); 3986 } 3987 break; 3988 case 10: 3989 { 3990 setState(547); 3991 dt(); 3992 } 3993 break; 3994 case 11: 3995 { 3996 setState(548); 3997 head(); 3998 } 3999 break; 4000 case 12: 4001 { 4002 setState(549); 4003 html(); 4004 } 4005 break; 4006 case 13: 4007 { 4008 setState(550); 4009 option(); 4010 } 4011 break; 4012 case 14: 4013 { 4014 setState(551); 4015 tbody(); 4016 } 4017 break; 4018 case 15: 4019 { 4020 setState(552); 4021 thead(); 4022 } 4023 break; 4024 case 16: 4025 { 4026 setState(553); 4027 tfoot(); 4028 } 4029 break; 4030 case 17: 4031 { 4032 setState(554); 4033 pTagOpen(); 4034 } 4035 break; 4036 case 18: 4037 { 4038 setState(555); 4039 liTagOpen(); 4040 } 4041 break; 4042 case 19: 4043 { 4044 setState(556); 4045 tdTagOpen(); 4046 } 4047 break; 4048 case 20: 4049 { 4050 setState(557); 4051 thTagOpen(); 4052 } 4053 break; 4054 case 21: 4055 { 4056 setState(558); 4057 bodyTagOpen(); 4058 } 4059 break; 4060 case 22: 4061 { 4062 setState(559); 4063 colgroupTagOpen(); 4064 } 4065 break; 4066 case 23: 4067 { 4068 setState(560); 4069 ddTagOpen(); 4070 } 4071 break; 4072 case 24: 4073 { 4074 setState(561); 4075 dtTagOpen(); 4076 } 4077 break; 4078 case 25: 4079 { 4080 setState(562); 4081 headTagOpen(); 4082 } 4083 break; 4084 case 26: 4085 { 4086 setState(563); 4087 htmlTagOpen(); 4088 } 4089 break; 4090 case 27: 4091 { 4092 setState(564); 4093 optionTagOpen(); 4094 } 4095 break; 4096 case 28: 4097 { 4098 setState(565); 4099 tbodyTagOpen(); 4100 } 4101 break; 4102 case 29: 4103 { 4104 setState(566); 4105 theadTagOpen(); 4106 } 4107 break; 4108 case 30: 4109 { 4110 setState(567); 4111 tfootTagOpen(); 4112 } 4113 break; 4114 case 31: 4115 { 4116 { 4117 setState(568); 4118 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4119 setState(569); 4120 match(LEADING_ASTERISK); 4121 } 4122 } 4123 break; 4124 case 32: 4125 { 4126 setState(570); 4127 htmlComment(); 4128 } 4129 break; 4130 case 33: 4131 { 4132 setState(571); 4133 match(CDATA); 4134 } 4135 break; 4136 case 34: 4137 { 4138 setState(572); 4139 match(NEWLINE); 4140 } 4141 break; 4142 case 35: 4143 { 4144 setState(573); 4145 text(); 4146 } 4147 break; 4148 case 36: 4149 { 4150 setState(574); 4151 javadocInlineTag(); 4152 } 4153 break; 4154 } 4155 } 4156 } 4157 setState(579); 4158 _errHandler.sync(this); 4159 _alt = getInterpreter().adaptivePredict(_input,36,_ctx); 4160 } 4161 setState(580); 4162 tdTagClose(); 4163 } 4164 } 4165 catch (RecognitionException re) { 4166 _localctx.exception = re; 4167 _errHandler.reportError(this, re); 4168 _errHandler.recover(this, re); 4169 } 4170 finally { 4171 exitRule(); 4172 } 4173 return _localctx; 4174 } 4175 4176 public static class ThTagOpenContext extends ParserRuleContext { 4177 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4178 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4179 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4180 public List<AttributeContext> attribute() { 4181 return getRuleContexts(AttributeContext.class); 4182 } 4183 public AttributeContext attribute(int i) { 4184 return getRuleContext(AttributeContext.class,i); 4185 } 4186 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4187 public TerminalNode NEWLINE(int i) { 4188 return getToken(JavadocParser.NEWLINE, i); 4189 } 4190 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4191 public TerminalNode LEADING_ASTERISK(int i) { 4192 return getToken(JavadocParser.LEADING_ASTERISK, i); 4193 } 4194 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4195 public TerminalNode WS(int i) { 4196 return getToken(JavadocParser.WS, i); 4197 } 4198 public ThTagOpenContext(ParserRuleContext parent, int invokingState) { 4199 super(parent, invokingState); 4200 } 4201 @Override public int getRuleIndex() { return RULE_thTagOpen; } 4202 @Override 4203 public void enterRule(ParseTreeListener listener) { 4204 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagOpen(this); 4205 } 4206 @Override 4207 public void exitRule(ParseTreeListener listener) { 4208 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagOpen(this); 4209 } 4210 @Override 4211 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4212 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagOpen(this); 4213 else return visitor.visitChildren(this); 4214 } 4215 } 4216 4217 public final ThTagOpenContext thTagOpen() throws RecognitionException { 4218 ThTagOpenContext _localctx = new ThTagOpenContext(_ctx, getState()); 4219 enterRule(_localctx, 36, RULE_thTagOpen); 4220 int _la; 4221 try { 4222 enterOuterAlt(_localctx, 1); 4223 { 4224 setState(582); 4225 match(OPEN); 4226 setState(583); 4227 match(TH_HTML_TAG_NAME); 4228 setState(590); 4229 _errHandler.sync(this); 4230 _la = _input.LA(1); 4231 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4232 { 4233 setState(588); 4234 switch (_input.LA(1)) { 4235 case HTML_TAG_NAME: 4236 { 4237 setState(584); 4238 attribute(); 4239 } 4240 break; 4241 case NEWLINE: 4242 { 4243 setState(585); 4244 match(NEWLINE); 4245 } 4246 break; 4247 case LEADING_ASTERISK: 4248 { 4249 setState(586); 4250 match(LEADING_ASTERISK); 4251 } 4252 break; 4253 case WS: 4254 { 4255 setState(587); 4256 match(WS); 4257 } 4258 break; 4259 default: 4260 throw new NoViableAltException(this); 4261 } 4262 } 4263 setState(592); 4264 _errHandler.sync(this); 4265 _la = _input.LA(1); 4266 } 4267 setState(593); 4268 match(CLOSE); 4269 } 4270 } 4271 catch (RecognitionException re) { 4272 _localctx.exception = re; 4273 _errHandler.reportError(this, re); 4274 _errHandler.recover(this, re); 4275 } 4276 finally { 4277 exitRule(); 4278 } 4279 return _localctx; 4280 } 4281 4282 public static class ThTagCloseContext extends ParserRuleContext { 4283 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4284 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4285 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4286 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4287 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4288 public TerminalNode NEWLINE(int i) { 4289 return getToken(JavadocParser.NEWLINE, i); 4290 } 4291 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4292 public TerminalNode LEADING_ASTERISK(int i) { 4293 return getToken(JavadocParser.LEADING_ASTERISK, i); 4294 } 4295 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4296 public TerminalNode WS(int i) { 4297 return getToken(JavadocParser.WS, i); 4298 } 4299 public ThTagCloseContext(ParserRuleContext parent, int invokingState) { 4300 super(parent, invokingState); 4301 } 4302 @Override public int getRuleIndex() { return RULE_thTagClose; } 4303 @Override 4304 public void enterRule(ParseTreeListener listener) { 4305 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagClose(this); 4306 } 4307 @Override 4308 public void exitRule(ParseTreeListener listener) { 4309 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagClose(this); 4310 } 4311 @Override 4312 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4313 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagClose(this); 4314 else return visitor.visitChildren(this); 4315 } 4316 } 4317 4318 public final ThTagCloseContext thTagClose() throws RecognitionException { 4319 ThTagCloseContext _localctx = new ThTagCloseContext(_ctx, getState()); 4320 enterRule(_localctx, 38, RULE_thTagClose); 4321 int _la; 4322 try { 4323 enterOuterAlt(_localctx, 1); 4324 { 4325 setState(595); 4326 match(OPEN); 4327 setState(596); 4328 match(SLASH); 4329 setState(597); 4330 match(TH_HTML_TAG_NAME); 4331 setState(601); 4332 _errHandler.sync(this); 4333 _la = _input.LA(1); 4334 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 4335 { 4336 { 4337 setState(598); 4338 _la = _input.LA(1); 4339 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 4340 _errHandler.recoverInline(this); 4341 } else { 4342 consume(); 4343 } 4344 } 4345 } 4346 setState(603); 4347 _errHandler.sync(this); 4348 _la = _input.LA(1); 4349 } 4350 setState(604); 4351 match(CLOSE); 4352 } 4353 } 4354 catch (RecognitionException re) { 4355 _localctx.exception = re; 4356 _errHandler.reportError(this, re); 4357 _errHandler.recover(this, re); 4358 } 4359 finally { 4360 exitRule(); 4361 } 4362 return _localctx; 4363 } 4364 4365 public static class ThContext extends ParserRuleContext { 4366 public ThTagOpenContext thTagOpen() { 4367 return getRuleContext(ThTagOpenContext.class,0); 4368 } 4369 public ThTagCloseContext thTagClose() { 4370 return getRuleContext(ThTagCloseContext.class,0); 4371 } 4372 public List<HtmlTagContext> htmlTag() { 4373 return getRuleContexts(HtmlTagContext.class); 4374 } 4375 public HtmlTagContext htmlTag(int i) { 4376 return getRuleContext(HtmlTagContext.class,i); 4377 } 4378 public List<SingletonTagContext> singletonTag() { 4379 return getRuleContexts(SingletonTagContext.class); 4380 } 4381 public SingletonTagContext singletonTag(int i) { 4382 return getRuleContext(SingletonTagContext.class,i); 4383 } 4384 public List<ParagraphContext> paragraph() { 4385 return getRuleContexts(ParagraphContext.class); 4386 } 4387 public ParagraphContext paragraph(int i) { 4388 return getRuleContext(ParagraphContext.class,i); 4389 } 4390 public List<LiContext> li() { 4391 return getRuleContexts(LiContext.class); 4392 } 4393 public LiContext li(int i) { 4394 return getRuleContext(LiContext.class,i); 4395 } 4396 public List<TrContext> tr() { 4397 return getRuleContexts(TrContext.class); 4398 } 4399 public TrContext tr(int i) { 4400 return getRuleContext(TrContext.class,i); 4401 } 4402 public List<TdContext> td() { 4403 return getRuleContexts(TdContext.class); 4404 } 4405 public TdContext td(int i) { 4406 return getRuleContext(TdContext.class,i); 4407 } 4408 public List<BodyContext> body() { 4409 return getRuleContexts(BodyContext.class); 4410 } 4411 public BodyContext body(int i) { 4412 return getRuleContext(BodyContext.class,i); 4413 } 4414 public List<ColgroupContext> colgroup() { 4415 return getRuleContexts(ColgroupContext.class); 4416 } 4417 public ColgroupContext colgroup(int i) { 4418 return getRuleContext(ColgroupContext.class,i); 4419 } 4420 public List<DdContext> dd() { 4421 return getRuleContexts(DdContext.class); 4422 } 4423 public DdContext dd(int i) { 4424 return getRuleContext(DdContext.class,i); 4425 } 4426 public List<DtContext> dt() { 4427 return getRuleContexts(DtContext.class); 4428 } 4429 public DtContext dt(int i) { 4430 return getRuleContext(DtContext.class,i); 4431 } 4432 public List<HeadContext> head() { 4433 return getRuleContexts(HeadContext.class); 4434 } 4435 public HeadContext head(int i) { 4436 return getRuleContext(HeadContext.class,i); 4437 } 4438 public List<HtmlContext> html() { 4439 return getRuleContexts(HtmlContext.class); 4440 } 4441 public HtmlContext html(int i) { 4442 return getRuleContext(HtmlContext.class,i); 4443 } 4444 public List<OptionContext> option() { 4445 return getRuleContexts(OptionContext.class); 4446 } 4447 public OptionContext option(int i) { 4448 return getRuleContext(OptionContext.class,i); 4449 } 4450 public List<TbodyContext> tbody() { 4451 return getRuleContexts(TbodyContext.class); 4452 } 4453 public TbodyContext tbody(int i) { 4454 return getRuleContext(TbodyContext.class,i); 4455 } 4456 public List<TheadContext> thead() { 4457 return getRuleContexts(TheadContext.class); 4458 } 4459 public TheadContext thead(int i) { 4460 return getRuleContext(TheadContext.class,i); 4461 } 4462 public List<TfootContext> tfoot() { 4463 return getRuleContexts(TfootContext.class); 4464 } 4465 public TfootContext tfoot(int i) { 4466 return getRuleContext(TfootContext.class,i); 4467 } 4468 public List<PTagOpenContext> pTagOpen() { 4469 return getRuleContexts(PTagOpenContext.class); 4470 } 4471 public PTagOpenContext pTagOpen(int i) { 4472 return getRuleContext(PTagOpenContext.class,i); 4473 } 4474 public List<LiTagOpenContext> liTagOpen() { 4475 return getRuleContexts(LiTagOpenContext.class); 4476 } 4477 public LiTagOpenContext liTagOpen(int i) { 4478 return getRuleContext(LiTagOpenContext.class,i); 4479 } 4480 public List<TrTagOpenContext> trTagOpen() { 4481 return getRuleContexts(TrTagOpenContext.class); 4482 } 4483 public TrTagOpenContext trTagOpen(int i) { 4484 return getRuleContext(TrTagOpenContext.class,i); 4485 } 4486 public List<TdTagOpenContext> tdTagOpen() { 4487 return getRuleContexts(TdTagOpenContext.class); 4488 } 4489 public TdTagOpenContext tdTagOpen(int i) { 4490 return getRuleContext(TdTagOpenContext.class,i); 4491 } 4492 public List<BodyTagOpenContext> bodyTagOpen() { 4493 return getRuleContexts(BodyTagOpenContext.class); 4494 } 4495 public BodyTagOpenContext bodyTagOpen(int i) { 4496 return getRuleContext(BodyTagOpenContext.class,i); 4497 } 4498 public List<ColgroupTagOpenContext> colgroupTagOpen() { 4499 return getRuleContexts(ColgroupTagOpenContext.class); 4500 } 4501 public ColgroupTagOpenContext colgroupTagOpen(int i) { 4502 return getRuleContext(ColgroupTagOpenContext.class,i); 4503 } 4504 public List<DdTagOpenContext> ddTagOpen() { 4505 return getRuleContexts(DdTagOpenContext.class); 4506 } 4507 public DdTagOpenContext ddTagOpen(int i) { 4508 return getRuleContext(DdTagOpenContext.class,i); 4509 } 4510 public List<DtTagOpenContext> dtTagOpen() { 4511 return getRuleContexts(DtTagOpenContext.class); 4512 } 4513 public DtTagOpenContext dtTagOpen(int i) { 4514 return getRuleContext(DtTagOpenContext.class,i); 4515 } 4516 public List<HeadTagOpenContext> headTagOpen() { 4517 return getRuleContexts(HeadTagOpenContext.class); 4518 } 4519 public HeadTagOpenContext headTagOpen(int i) { 4520 return getRuleContext(HeadTagOpenContext.class,i); 4521 } 4522 public List<HtmlTagOpenContext> htmlTagOpen() { 4523 return getRuleContexts(HtmlTagOpenContext.class); 4524 } 4525 public HtmlTagOpenContext htmlTagOpen(int i) { 4526 return getRuleContext(HtmlTagOpenContext.class,i); 4527 } 4528 public List<OptionTagOpenContext> optionTagOpen() { 4529 return getRuleContexts(OptionTagOpenContext.class); 4530 } 4531 public OptionTagOpenContext optionTagOpen(int i) { 4532 return getRuleContext(OptionTagOpenContext.class,i); 4533 } 4534 public List<TbodyTagOpenContext> tbodyTagOpen() { 4535 return getRuleContexts(TbodyTagOpenContext.class); 4536 } 4537 public TbodyTagOpenContext tbodyTagOpen(int i) { 4538 return getRuleContext(TbodyTagOpenContext.class,i); 4539 } 4540 public List<TheadTagOpenContext> theadTagOpen() { 4541 return getRuleContexts(TheadTagOpenContext.class); 4542 } 4543 public TheadTagOpenContext theadTagOpen(int i) { 4544 return getRuleContext(TheadTagOpenContext.class,i); 4545 } 4546 public List<TfootTagOpenContext> tfootTagOpen() { 4547 return getRuleContexts(TfootTagOpenContext.class); 4548 } 4549 public TfootTagOpenContext tfootTagOpen(int i) { 4550 return getRuleContext(TfootTagOpenContext.class,i); 4551 } 4552 public List<HtmlCommentContext> htmlComment() { 4553 return getRuleContexts(HtmlCommentContext.class); 4554 } 4555 public HtmlCommentContext htmlComment(int i) { 4556 return getRuleContext(HtmlCommentContext.class,i); 4557 } 4558 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 4559 public TerminalNode CDATA(int i) { 4560 return getToken(JavadocParser.CDATA, i); 4561 } 4562 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4563 public TerminalNode NEWLINE(int i) { 4564 return getToken(JavadocParser.NEWLINE, i); 4565 } 4566 public List<TextContext> text() { 4567 return getRuleContexts(TextContext.class); 4568 } 4569 public TextContext text(int i) { 4570 return getRuleContext(TextContext.class,i); 4571 } 4572 public List<JavadocInlineTagContext> javadocInlineTag() { 4573 return getRuleContexts(JavadocInlineTagContext.class); 4574 } 4575 public JavadocInlineTagContext javadocInlineTag(int i) { 4576 return getRuleContext(JavadocInlineTagContext.class,i); 4577 } 4578 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4579 public TerminalNode LEADING_ASTERISK(int i) { 4580 return getToken(JavadocParser.LEADING_ASTERISK, i); 4581 } 4582 public ThContext(ParserRuleContext parent, int invokingState) { 4583 super(parent, invokingState); 4584 } 4585 @Override public int getRuleIndex() { return RULE_th; } 4586 @Override 4587 public void enterRule(ParseTreeListener listener) { 4588 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTh(this); 4589 } 4590 @Override 4591 public void exitRule(ParseTreeListener listener) { 4592 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTh(this); 4593 } 4594 @Override 4595 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4596 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTh(this); 4597 else return visitor.visitChildren(this); 4598 } 4599 } 4600 4601 public final ThContext th() throws RecognitionException { 4602 ThContext _localctx = new ThContext(_ctx, getState()); 4603 enterRule(_localctx, 40, RULE_th); 4604 try { 4605 int _alt; 4606 enterOuterAlt(_localctx, 1); 4607 { 4608 setState(606); 4609 thTagOpen(); 4610 setState(646); 4611 _errHandler.sync(this); 4612 _alt = getInterpreter().adaptivePredict(_input,41,_ctx); 4613 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 4614 if ( _alt==1 ) { 4615 { 4616 setState(644); 4617 _errHandler.sync(this); 4618 switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { 4619 case 1: 4620 { 4621 setState(607); 4622 htmlTag(); 4623 } 4624 break; 4625 case 2: 4626 { 4627 setState(608); 4628 singletonTag(); 4629 } 4630 break; 4631 case 3: 4632 { 4633 setState(609); 4634 paragraph(); 4635 } 4636 break; 4637 case 4: 4638 { 4639 setState(610); 4640 li(); 4641 } 4642 break; 4643 case 5: 4644 { 4645 setState(611); 4646 tr(); 4647 } 4648 break; 4649 case 6: 4650 { 4651 setState(612); 4652 td(); 4653 } 4654 break; 4655 case 7: 4656 { 4657 setState(613); 4658 body(); 4659 } 4660 break; 4661 case 8: 4662 { 4663 setState(614); 4664 colgroup(); 4665 } 4666 break; 4667 case 9: 4668 { 4669 setState(615); 4670 dd(); 4671 } 4672 break; 4673 case 10: 4674 { 4675 setState(616); 4676 dt(); 4677 } 4678 break; 4679 case 11: 4680 { 4681 setState(617); 4682 head(); 4683 } 4684 break; 4685 case 12: 4686 { 4687 setState(618); 4688 html(); 4689 } 4690 break; 4691 case 13: 4692 { 4693 setState(619); 4694 option(); 4695 } 4696 break; 4697 case 14: 4698 { 4699 setState(620); 4700 tbody(); 4701 } 4702 break; 4703 case 15: 4704 { 4705 setState(621); 4706 thead(); 4707 } 4708 break; 4709 case 16: 4710 { 4711 setState(622); 4712 tfoot(); 4713 } 4714 break; 4715 case 17: 4716 { 4717 setState(623); 4718 pTagOpen(); 4719 } 4720 break; 4721 case 18: 4722 { 4723 setState(624); 4724 liTagOpen(); 4725 } 4726 break; 4727 case 19: 4728 { 4729 setState(625); 4730 trTagOpen(); 4731 } 4732 break; 4733 case 20: 4734 { 4735 setState(626); 4736 tdTagOpen(); 4737 } 4738 break; 4739 case 21: 4740 { 4741 setState(627); 4742 bodyTagOpen(); 4743 } 4744 break; 4745 case 22: 4746 { 4747 setState(628); 4748 colgroupTagOpen(); 4749 } 4750 break; 4751 case 23: 4752 { 4753 setState(629); 4754 ddTagOpen(); 4755 } 4756 break; 4757 case 24: 4758 { 4759 setState(630); 4760 dtTagOpen(); 4761 } 4762 break; 4763 case 25: 4764 { 4765 setState(631); 4766 headTagOpen(); 4767 } 4768 break; 4769 case 26: 4770 { 4771 setState(632); 4772 htmlTagOpen(); 4773 } 4774 break; 4775 case 27: 4776 { 4777 setState(633); 4778 optionTagOpen(); 4779 } 4780 break; 4781 case 28: 4782 { 4783 setState(634); 4784 tbodyTagOpen(); 4785 } 4786 break; 4787 case 29: 4788 { 4789 setState(635); 4790 theadTagOpen(); 4791 } 4792 break; 4793 case 30: 4794 { 4795 setState(636); 4796 tfootTagOpen(); 4797 } 4798 break; 4799 case 31: 4800 { 4801 { 4802 setState(637); 4803 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4804 setState(638); 4805 match(LEADING_ASTERISK); 4806 } 4807 } 4808 break; 4809 case 32: 4810 { 4811 setState(639); 4812 htmlComment(); 4813 } 4814 break; 4815 case 33: 4816 { 4817 setState(640); 4818 match(CDATA); 4819 } 4820 break; 4821 case 34: 4822 { 4823 setState(641); 4824 match(NEWLINE); 4825 } 4826 break; 4827 case 35: 4828 { 4829 setState(642); 4830 text(); 4831 } 4832 break; 4833 case 36: 4834 { 4835 setState(643); 4836 javadocInlineTag(); 4837 } 4838 break; 4839 } 4840 } 4841 } 4842 setState(648); 4843 _errHandler.sync(this); 4844 _alt = getInterpreter().adaptivePredict(_input,41,_ctx); 4845 } 4846 setState(649); 4847 thTagClose(); 4848 } 4849 } 4850 catch (RecognitionException re) { 4851 _localctx.exception = re; 4852 _errHandler.reportError(this, re); 4853 _errHandler.recover(this, re); 4854 } 4855 finally { 4856 exitRule(); 4857 } 4858 return _localctx; 4859 } 4860 4861 public static class BodyTagOpenContext extends ParserRuleContext { 4862 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4863 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 4864 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4865 public List<AttributeContext> attribute() { 4866 return getRuleContexts(AttributeContext.class); 4867 } 4868 public AttributeContext attribute(int i) { 4869 return getRuleContext(AttributeContext.class,i); 4870 } 4871 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4872 public TerminalNode NEWLINE(int i) { 4873 return getToken(JavadocParser.NEWLINE, i); 4874 } 4875 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4876 public TerminalNode LEADING_ASTERISK(int i) { 4877 return getToken(JavadocParser.LEADING_ASTERISK, i); 4878 } 4879 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4880 public TerminalNode WS(int i) { 4881 return getToken(JavadocParser.WS, i); 4882 } 4883 public BodyTagOpenContext(ParserRuleContext parent, int invokingState) { 4884 super(parent, invokingState); 4885 } 4886 @Override public int getRuleIndex() { return RULE_bodyTagOpen; } 4887 @Override 4888 public void enterRule(ParseTreeListener listener) { 4889 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagOpen(this); 4890 } 4891 @Override 4892 public void exitRule(ParseTreeListener listener) { 4893 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagOpen(this); 4894 } 4895 @Override 4896 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4897 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagOpen(this); 4898 else return visitor.visitChildren(this); 4899 } 4900 } 4901 4902 public final BodyTagOpenContext bodyTagOpen() throws RecognitionException { 4903 BodyTagOpenContext _localctx = new BodyTagOpenContext(_ctx, getState()); 4904 enterRule(_localctx, 42, RULE_bodyTagOpen); 4905 int _la; 4906 try { 4907 enterOuterAlt(_localctx, 1); 4908 { 4909 setState(651); 4910 match(OPEN); 4911 setState(652); 4912 match(BODY_HTML_TAG_NAME); 4913 setState(659); 4914 _errHandler.sync(this); 4915 _la = _input.LA(1); 4916 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4917 { 4918 setState(657); 4919 switch (_input.LA(1)) { 4920 case HTML_TAG_NAME: 4921 { 4922 setState(653); 4923 attribute(); 4924 } 4925 break; 4926 case NEWLINE: 4927 { 4928 setState(654); 4929 match(NEWLINE); 4930 } 4931 break; 4932 case LEADING_ASTERISK: 4933 { 4934 setState(655); 4935 match(LEADING_ASTERISK); 4936 } 4937 break; 4938 case WS: 4939 { 4940 setState(656); 4941 match(WS); 4942 } 4943 break; 4944 default: 4945 throw new NoViableAltException(this); 4946 } 4947 } 4948 setState(661); 4949 _errHandler.sync(this); 4950 _la = _input.LA(1); 4951 } 4952 setState(662); 4953 match(CLOSE); 4954 } 4955 } 4956 catch (RecognitionException re) { 4957 _localctx.exception = re; 4958 _errHandler.reportError(this, re); 4959 _errHandler.recover(this, re); 4960 } 4961 finally { 4962 exitRule(); 4963 } 4964 return _localctx; 4965 } 4966 4967 public static class BodyTagCloseContext extends ParserRuleContext { 4968 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4969 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4970 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 4971 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4972 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4973 public TerminalNode NEWLINE(int i) { 4974 return getToken(JavadocParser.NEWLINE, i); 4975 } 4976 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4977 public TerminalNode LEADING_ASTERISK(int i) { 4978 return getToken(JavadocParser.LEADING_ASTERISK, i); 4979 } 4980 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4981 public TerminalNode WS(int i) { 4982 return getToken(JavadocParser.WS, i); 4983 } 4984 public BodyTagCloseContext(ParserRuleContext parent, int invokingState) { 4985 super(parent, invokingState); 4986 } 4987 @Override public int getRuleIndex() { return RULE_bodyTagClose; } 4988 @Override 4989 public void enterRule(ParseTreeListener listener) { 4990 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagClose(this); 4991 } 4992 @Override 4993 public void exitRule(ParseTreeListener listener) { 4994 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagClose(this); 4995 } 4996 @Override 4997 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4998 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagClose(this); 4999 else return visitor.visitChildren(this); 5000 } 5001 } 5002 5003 public final BodyTagCloseContext bodyTagClose() throws RecognitionException { 5004 BodyTagCloseContext _localctx = new BodyTagCloseContext(_ctx, getState()); 5005 enterRule(_localctx, 44, RULE_bodyTagClose); 5006 int _la; 5007 try { 5008 enterOuterAlt(_localctx, 1); 5009 { 5010 setState(664); 5011 match(OPEN); 5012 setState(665); 5013 match(SLASH); 5014 setState(666); 5015 match(BODY_HTML_TAG_NAME); 5016 setState(670); 5017 _errHandler.sync(this); 5018 _la = _input.LA(1); 5019 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5020 { 5021 { 5022 setState(667); 5023 _la = _input.LA(1); 5024 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5025 _errHandler.recoverInline(this); 5026 } else { 5027 consume(); 5028 } 5029 } 5030 } 5031 setState(672); 5032 _errHandler.sync(this); 5033 _la = _input.LA(1); 5034 } 5035 setState(673); 5036 match(CLOSE); 5037 } 5038 } 5039 catch (RecognitionException re) { 5040 _localctx.exception = re; 5041 _errHandler.reportError(this, re); 5042 _errHandler.recover(this, re); 5043 } 5044 finally { 5045 exitRule(); 5046 } 5047 return _localctx; 5048 } 5049 5050 public static class BodyContext extends ParserRuleContext { 5051 public BodyTagOpenContext bodyTagOpen() { 5052 return getRuleContext(BodyTagOpenContext.class,0); 5053 } 5054 public BodyTagCloseContext bodyTagClose() { 5055 return getRuleContext(BodyTagCloseContext.class,0); 5056 } 5057 public List<HtmlTagContext> htmlTag() { 5058 return getRuleContexts(HtmlTagContext.class); 5059 } 5060 public HtmlTagContext htmlTag(int i) { 5061 return getRuleContext(HtmlTagContext.class,i); 5062 } 5063 public List<SingletonTagContext> singletonTag() { 5064 return getRuleContexts(SingletonTagContext.class); 5065 } 5066 public SingletonTagContext singletonTag(int i) { 5067 return getRuleContext(SingletonTagContext.class,i); 5068 } 5069 public List<ParagraphContext> paragraph() { 5070 return getRuleContexts(ParagraphContext.class); 5071 } 5072 public ParagraphContext paragraph(int i) { 5073 return getRuleContext(ParagraphContext.class,i); 5074 } 5075 public List<LiContext> li() { 5076 return getRuleContexts(LiContext.class); 5077 } 5078 public LiContext li(int i) { 5079 return getRuleContext(LiContext.class,i); 5080 } 5081 public List<TrContext> tr() { 5082 return getRuleContexts(TrContext.class); 5083 } 5084 public TrContext tr(int i) { 5085 return getRuleContext(TrContext.class,i); 5086 } 5087 public List<TdContext> td() { 5088 return getRuleContexts(TdContext.class); 5089 } 5090 public TdContext td(int i) { 5091 return getRuleContext(TdContext.class,i); 5092 } 5093 public List<ThContext> th() { 5094 return getRuleContexts(ThContext.class); 5095 } 5096 public ThContext th(int i) { 5097 return getRuleContext(ThContext.class,i); 5098 } 5099 public List<ColgroupContext> colgroup() { 5100 return getRuleContexts(ColgroupContext.class); 5101 } 5102 public ColgroupContext colgroup(int i) { 5103 return getRuleContext(ColgroupContext.class,i); 5104 } 5105 public List<DdContext> dd() { 5106 return getRuleContexts(DdContext.class); 5107 } 5108 public DdContext dd(int i) { 5109 return getRuleContext(DdContext.class,i); 5110 } 5111 public List<DtContext> dt() { 5112 return getRuleContexts(DtContext.class); 5113 } 5114 public DtContext dt(int i) { 5115 return getRuleContext(DtContext.class,i); 5116 } 5117 public List<HeadContext> head() { 5118 return getRuleContexts(HeadContext.class); 5119 } 5120 public HeadContext head(int i) { 5121 return getRuleContext(HeadContext.class,i); 5122 } 5123 public List<HtmlContext> html() { 5124 return getRuleContexts(HtmlContext.class); 5125 } 5126 public HtmlContext html(int i) { 5127 return getRuleContext(HtmlContext.class,i); 5128 } 5129 public List<OptionContext> option() { 5130 return getRuleContexts(OptionContext.class); 5131 } 5132 public OptionContext option(int i) { 5133 return getRuleContext(OptionContext.class,i); 5134 } 5135 public List<TbodyContext> tbody() { 5136 return getRuleContexts(TbodyContext.class); 5137 } 5138 public TbodyContext tbody(int i) { 5139 return getRuleContext(TbodyContext.class,i); 5140 } 5141 public List<TheadContext> thead() { 5142 return getRuleContexts(TheadContext.class); 5143 } 5144 public TheadContext thead(int i) { 5145 return getRuleContext(TheadContext.class,i); 5146 } 5147 public List<TfootContext> tfoot() { 5148 return getRuleContexts(TfootContext.class); 5149 } 5150 public TfootContext tfoot(int i) { 5151 return getRuleContext(TfootContext.class,i); 5152 } 5153 public List<PTagOpenContext> pTagOpen() { 5154 return getRuleContexts(PTagOpenContext.class); 5155 } 5156 public PTagOpenContext pTagOpen(int i) { 5157 return getRuleContext(PTagOpenContext.class,i); 5158 } 5159 public List<LiTagOpenContext> liTagOpen() { 5160 return getRuleContexts(LiTagOpenContext.class); 5161 } 5162 public LiTagOpenContext liTagOpen(int i) { 5163 return getRuleContext(LiTagOpenContext.class,i); 5164 } 5165 public List<TrTagOpenContext> trTagOpen() { 5166 return getRuleContexts(TrTagOpenContext.class); 5167 } 5168 public TrTagOpenContext trTagOpen(int i) { 5169 return getRuleContext(TrTagOpenContext.class,i); 5170 } 5171 public List<TdTagOpenContext> tdTagOpen() { 5172 return getRuleContexts(TdTagOpenContext.class); 5173 } 5174 public TdTagOpenContext tdTagOpen(int i) { 5175 return getRuleContext(TdTagOpenContext.class,i); 5176 } 5177 public List<ThTagOpenContext> thTagOpen() { 5178 return getRuleContexts(ThTagOpenContext.class); 5179 } 5180 public ThTagOpenContext thTagOpen(int i) { 5181 return getRuleContext(ThTagOpenContext.class,i); 5182 } 5183 public List<ColgroupTagOpenContext> colgroupTagOpen() { 5184 return getRuleContexts(ColgroupTagOpenContext.class); 5185 } 5186 public ColgroupTagOpenContext colgroupTagOpen(int i) { 5187 return getRuleContext(ColgroupTagOpenContext.class,i); 5188 } 5189 public List<DdTagOpenContext> ddTagOpen() { 5190 return getRuleContexts(DdTagOpenContext.class); 5191 } 5192 public DdTagOpenContext ddTagOpen(int i) { 5193 return getRuleContext(DdTagOpenContext.class,i); 5194 } 5195 public List<DtTagOpenContext> dtTagOpen() { 5196 return getRuleContexts(DtTagOpenContext.class); 5197 } 5198 public DtTagOpenContext dtTagOpen(int i) { 5199 return getRuleContext(DtTagOpenContext.class,i); 5200 } 5201 public List<HeadTagOpenContext> headTagOpen() { 5202 return getRuleContexts(HeadTagOpenContext.class); 5203 } 5204 public HeadTagOpenContext headTagOpen(int i) { 5205 return getRuleContext(HeadTagOpenContext.class,i); 5206 } 5207 public List<HtmlTagOpenContext> htmlTagOpen() { 5208 return getRuleContexts(HtmlTagOpenContext.class); 5209 } 5210 public HtmlTagOpenContext htmlTagOpen(int i) { 5211 return getRuleContext(HtmlTagOpenContext.class,i); 5212 } 5213 public List<OptionTagOpenContext> optionTagOpen() { 5214 return getRuleContexts(OptionTagOpenContext.class); 5215 } 5216 public OptionTagOpenContext optionTagOpen(int i) { 5217 return getRuleContext(OptionTagOpenContext.class,i); 5218 } 5219 public List<TbodyTagOpenContext> tbodyTagOpen() { 5220 return getRuleContexts(TbodyTagOpenContext.class); 5221 } 5222 public TbodyTagOpenContext tbodyTagOpen(int i) { 5223 return getRuleContext(TbodyTagOpenContext.class,i); 5224 } 5225 public List<TheadTagOpenContext> theadTagOpen() { 5226 return getRuleContexts(TheadTagOpenContext.class); 5227 } 5228 public TheadTagOpenContext theadTagOpen(int i) { 5229 return getRuleContext(TheadTagOpenContext.class,i); 5230 } 5231 public List<TfootTagOpenContext> tfootTagOpen() { 5232 return getRuleContexts(TfootTagOpenContext.class); 5233 } 5234 public TfootTagOpenContext tfootTagOpen(int i) { 5235 return getRuleContext(TfootTagOpenContext.class,i); 5236 } 5237 public List<HtmlCommentContext> htmlComment() { 5238 return getRuleContexts(HtmlCommentContext.class); 5239 } 5240 public HtmlCommentContext htmlComment(int i) { 5241 return getRuleContext(HtmlCommentContext.class,i); 5242 } 5243 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5244 public TerminalNode CDATA(int i) { 5245 return getToken(JavadocParser.CDATA, i); 5246 } 5247 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5248 public TerminalNode NEWLINE(int i) { 5249 return getToken(JavadocParser.NEWLINE, i); 5250 } 5251 public List<TextContext> text() { 5252 return getRuleContexts(TextContext.class); 5253 } 5254 public TextContext text(int i) { 5255 return getRuleContext(TextContext.class,i); 5256 } 5257 public List<JavadocInlineTagContext> javadocInlineTag() { 5258 return getRuleContexts(JavadocInlineTagContext.class); 5259 } 5260 public JavadocInlineTagContext javadocInlineTag(int i) { 5261 return getRuleContext(JavadocInlineTagContext.class,i); 5262 } 5263 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5264 public TerminalNode LEADING_ASTERISK(int i) { 5265 return getToken(JavadocParser.LEADING_ASTERISK, i); 5266 } 5267 public BodyContext(ParserRuleContext parent, int invokingState) { 5268 super(parent, invokingState); 5269 } 5270 @Override public int getRuleIndex() { return RULE_body; } 5271 @Override 5272 public void enterRule(ParseTreeListener listener) { 5273 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBody(this); 5274 } 5275 @Override 5276 public void exitRule(ParseTreeListener listener) { 5277 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBody(this); 5278 } 5279 @Override 5280 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5281 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBody(this); 5282 else return visitor.visitChildren(this); 5283 } 5284 } 5285 5286 public final BodyContext body() throws RecognitionException { 5287 BodyContext _localctx = new BodyContext(_ctx, getState()); 5288 enterRule(_localctx, 46, RULE_body); 5289 try { 5290 int _alt; 5291 enterOuterAlt(_localctx, 1); 5292 { 5293 setState(675); 5294 bodyTagOpen(); 5295 setState(715); 5296 _errHandler.sync(this); 5297 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5298 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5299 if ( _alt==1 ) { 5300 { 5301 setState(713); 5302 _errHandler.sync(this); 5303 switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { 5304 case 1: 5305 { 5306 setState(676); 5307 htmlTag(); 5308 } 5309 break; 5310 case 2: 5311 { 5312 setState(677); 5313 singletonTag(); 5314 } 5315 break; 5316 case 3: 5317 { 5318 setState(678); 5319 paragraph(); 5320 } 5321 break; 5322 case 4: 5323 { 5324 setState(679); 5325 li(); 5326 } 5327 break; 5328 case 5: 5329 { 5330 setState(680); 5331 tr(); 5332 } 5333 break; 5334 case 6: 5335 { 5336 setState(681); 5337 td(); 5338 } 5339 break; 5340 case 7: 5341 { 5342 setState(682); 5343 th(); 5344 } 5345 break; 5346 case 8: 5347 { 5348 setState(683); 5349 colgroup(); 5350 } 5351 break; 5352 case 9: 5353 { 5354 setState(684); 5355 dd(); 5356 } 5357 break; 5358 case 10: 5359 { 5360 setState(685); 5361 dt(); 5362 } 5363 break; 5364 case 11: 5365 { 5366 setState(686); 5367 head(); 5368 } 5369 break; 5370 case 12: 5371 { 5372 setState(687); 5373 html(); 5374 } 5375 break; 5376 case 13: 5377 { 5378 setState(688); 5379 option(); 5380 } 5381 break; 5382 case 14: 5383 { 5384 setState(689); 5385 tbody(); 5386 } 5387 break; 5388 case 15: 5389 { 5390 setState(690); 5391 thead(); 5392 } 5393 break; 5394 case 16: 5395 { 5396 setState(691); 5397 tfoot(); 5398 } 5399 break; 5400 case 17: 5401 { 5402 setState(692); 5403 pTagOpen(); 5404 } 5405 break; 5406 case 18: 5407 { 5408 setState(693); 5409 liTagOpen(); 5410 } 5411 break; 5412 case 19: 5413 { 5414 setState(694); 5415 trTagOpen(); 5416 } 5417 break; 5418 case 20: 5419 { 5420 setState(695); 5421 tdTagOpen(); 5422 } 5423 break; 5424 case 21: 5425 { 5426 setState(696); 5427 thTagOpen(); 5428 } 5429 break; 5430 case 22: 5431 { 5432 setState(697); 5433 colgroupTagOpen(); 5434 } 5435 break; 5436 case 23: 5437 { 5438 setState(698); 5439 ddTagOpen(); 5440 } 5441 break; 5442 case 24: 5443 { 5444 setState(699); 5445 dtTagOpen(); 5446 } 5447 break; 5448 case 25: 5449 { 5450 setState(700); 5451 headTagOpen(); 5452 } 5453 break; 5454 case 26: 5455 { 5456 setState(701); 5457 htmlTagOpen(); 5458 } 5459 break; 5460 case 27: 5461 { 5462 setState(702); 5463 optionTagOpen(); 5464 } 5465 break; 5466 case 28: 5467 { 5468 setState(703); 5469 tbodyTagOpen(); 5470 } 5471 break; 5472 case 29: 5473 { 5474 setState(704); 5475 theadTagOpen(); 5476 } 5477 break; 5478 case 30: 5479 { 5480 setState(705); 5481 tfootTagOpen(); 5482 } 5483 break; 5484 case 31: 5485 { 5486 { 5487 setState(706); 5488 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 5489 setState(707); 5490 match(LEADING_ASTERISK); 5491 } 5492 } 5493 break; 5494 case 32: 5495 { 5496 setState(708); 5497 htmlComment(); 5498 } 5499 break; 5500 case 33: 5501 { 5502 setState(709); 5503 match(CDATA); 5504 } 5505 break; 5506 case 34: 5507 { 5508 setState(710); 5509 match(NEWLINE); 5510 } 5511 break; 5512 case 35: 5513 { 5514 setState(711); 5515 text(); 5516 } 5517 break; 5518 case 36: 5519 { 5520 setState(712); 5521 javadocInlineTag(); 5522 } 5523 break; 5524 } 5525 } 5526 } 5527 setState(717); 5528 _errHandler.sync(this); 5529 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5530 } 5531 setState(718); 5532 bodyTagClose(); 5533 } 5534 } 5535 catch (RecognitionException re) { 5536 _localctx.exception = re; 5537 _errHandler.reportError(this, re); 5538 _errHandler.recover(this, re); 5539 } 5540 finally { 5541 exitRule(); 5542 } 5543 return _localctx; 5544 } 5545 5546 public static class ColgroupTagOpenContext extends ParserRuleContext { 5547 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5548 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5549 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5550 public List<AttributeContext> attribute() { 5551 return getRuleContexts(AttributeContext.class); 5552 } 5553 public AttributeContext attribute(int i) { 5554 return getRuleContext(AttributeContext.class,i); 5555 } 5556 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5557 public TerminalNode NEWLINE(int i) { 5558 return getToken(JavadocParser.NEWLINE, i); 5559 } 5560 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5561 public TerminalNode LEADING_ASTERISK(int i) { 5562 return getToken(JavadocParser.LEADING_ASTERISK, i); 5563 } 5564 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5565 public TerminalNode WS(int i) { 5566 return getToken(JavadocParser.WS, i); 5567 } 5568 public ColgroupTagOpenContext(ParserRuleContext parent, int invokingState) { 5569 super(parent, invokingState); 5570 } 5571 @Override public int getRuleIndex() { return RULE_colgroupTagOpen; } 5572 @Override 5573 public void enterRule(ParseTreeListener listener) { 5574 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagOpen(this); 5575 } 5576 @Override 5577 public void exitRule(ParseTreeListener listener) { 5578 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagOpen(this); 5579 } 5580 @Override 5581 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5582 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagOpen(this); 5583 else return visitor.visitChildren(this); 5584 } 5585 } 5586 5587 public final ColgroupTagOpenContext colgroupTagOpen() throws RecognitionException { 5588 ColgroupTagOpenContext _localctx = new ColgroupTagOpenContext(_ctx, getState()); 5589 enterRule(_localctx, 48, RULE_colgroupTagOpen); 5590 int _la; 5591 try { 5592 enterOuterAlt(_localctx, 1); 5593 { 5594 setState(720); 5595 match(OPEN); 5596 setState(721); 5597 match(COLGROUP_HTML_TAG_NAME); 5598 setState(728); 5599 _errHandler.sync(this); 5600 _la = _input.LA(1); 5601 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 5602 { 5603 setState(726); 5604 switch (_input.LA(1)) { 5605 case HTML_TAG_NAME: 5606 { 5607 setState(722); 5608 attribute(); 5609 } 5610 break; 5611 case NEWLINE: 5612 { 5613 setState(723); 5614 match(NEWLINE); 5615 } 5616 break; 5617 case LEADING_ASTERISK: 5618 { 5619 setState(724); 5620 match(LEADING_ASTERISK); 5621 } 5622 break; 5623 case WS: 5624 { 5625 setState(725); 5626 match(WS); 5627 } 5628 break; 5629 default: 5630 throw new NoViableAltException(this); 5631 } 5632 } 5633 setState(730); 5634 _errHandler.sync(this); 5635 _la = _input.LA(1); 5636 } 5637 setState(731); 5638 match(CLOSE); 5639 } 5640 } 5641 catch (RecognitionException re) { 5642 _localctx.exception = re; 5643 _errHandler.reportError(this, re); 5644 _errHandler.recover(this, re); 5645 } 5646 finally { 5647 exitRule(); 5648 } 5649 return _localctx; 5650 } 5651 5652 public static class ColgroupTagCloseContext extends ParserRuleContext { 5653 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5654 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 5655 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5656 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5657 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5658 public TerminalNode NEWLINE(int i) { 5659 return getToken(JavadocParser.NEWLINE, i); 5660 } 5661 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5662 public TerminalNode LEADING_ASTERISK(int i) { 5663 return getToken(JavadocParser.LEADING_ASTERISK, i); 5664 } 5665 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5666 public TerminalNode WS(int i) { 5667 return getToken(JavadocParser.WS, i); 5668 } 5669 public ColgroupTagCloseContext(ParserRuleContext parent, int invokingState) { 5670 super(parent, invokingState); 5671 } 5672 @Override public int getRuleIndex() { return RULE_colgroupTagClose; } 5673 @Override 5674 public void enterRule(ParseTreeListener listener) { 5675 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagClose(this); 5676 } 5677 @Override 5678 public void exitRule(ParseTreeListener listener) { 5679 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagClose(this); 5680 } 5681 @Override 5682 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5683 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagClose(this); 5684 else return visitor.visitChildren(this); 5685 } 5686 } 5687 5688 public final ColgroupTagCloseContext colgroupTagClose() throws RecognitionException { 5689 ColgroupTagCloseContext _localctx = new ColgroupTagCloseContext(_ctx, getState()); 5690 enterRule(_localctx, 50, RULE_colgroupTagClose); 5691 int _la; 5692 try { 5693 enterOuterAlt(_localctx, 1); 5694 { 5695 setState(733); 5696 match(OPEN); 5697 setState(734); 5698 match(SLASH); 5699 setState(735); 5700 match(COLGROUP_HTML_TAG_NAME); 5701 setState(739); 5702 _errHandler.sync(this); 5703 _la = _input.LA(1); 5704 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5705 { 5706 { 5707 setState(736); 5708 _la = _input.LA(1); 5709 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5710 _errHandler.recoverInline(this); 5711 } else { 5712 consume(); 5713 } 5714 } 5715 } 5716 setState(741); 5717 _errHandler.sync(this); 5718 _la = _input.LA(1); 5719 } 5720 setState(742); 5721 match(CLOSE); 5722 } 5723 } 5724 catch (RecognitionException re) { 5725 _localctx.exception = re; 5726 _errHandler.reportError(this, re); 5727 _errHandler.recover(this, re); 5728 } 5729 finally { 5730 exitRule(); 5731 } 5732 return _localctx; 5733 } 5734 5735 public static class ColgroupContext extends ParserRuleContext { 5736 public ColgroupTagOpenContext colgroupTagOpen() { 5737 return getRuleContext(ColgroupTagOpenContext.class,0); 5738 } 5739 public ColgroupTagCloseContext colgroupTagClose() { 5740 return getRuleContext(ColgroupTagCloseContext.class,0); 5741 } 5742 public List<HtmlTagContext> htmlTag() { 5743 return getRuleContexts(HtmlTagContext.class); 5744 } 5745 public HtmlTagContext htmlTag(int i) { 5746 return getRuleContext(HtmlTagContext.class,i); 5747 } 5748 public List<SingletonTagContext> singletonTag() { 5749 return getRuleContexts(SingletonTagContext.class); 5750 } 5751 public SingletonTagContext singletonTag(int i) { 5752 return getRuleContext(SingletonTagContext.class,i); 5753 } 5754 public List<ParagraphContext> paragraph() { 5755 return getRuleContexts(ParagraphContext.class); 5756 } 5757 public ParagraphContext paragraph(int i) { 5758 return getRuleContext(ParagraphContext.class,i); 5759 } 5760 public List<LiContext> li() { 5761 return getRuleContexts(LiContext.class); 5762 } 5763 public LiContext li(int i) { 5764 return getRuleContext(LiContext.class,i); 5765 } 5766 public List<TrContext> tr() { 5767 return getRuleContexts(TrContext.class); 5768 } 5769 public TrContext tr(int i) { 5770 return getRuleContext(TrContext.class,i); 5771 } 5772 public List<TdContext> td() { 5773 return getRuleContexts(TdContext.class); 5774 } 5775 public TdContext td(int i) { 5776 return getRuleContext(TdContext.class,i); 5777 } 5778 public List<ThContext> th() { 5779 return getRuleContexts(ThContext.class); 5780 } 5781 public ThContext th(int i) { 5782 return getRuleContext(ThContext.class,i); 5783 } 5784 public List<BodyContext> body() { 5785 return getRuleContexts(BodyContext.class); 5786 } 5787 public BodyContext body(int i) { 5788 return getRuleContext(BodyContext.class,i); 5789 } 5790 public List<DdContext> dd() { 5791 return getRuleContexts(DdContext.class); 5792 } 5793 public DdContext dd(int i) { 5794 return getRuleContext(DdContext.class,i); 5795 } 5796 public List<DtContext> dt() { 5797 return getRuleContexts(DtContext.class); 5798 } 5799 public DtContext dt(int i) { 5800 return getRuleContext(DtContext.class,i); 5801 } 5802 public List<HeadContext> head() { 5803 return getRuleContexts(HeadContext.class); 5804 } 5805 public HeadContext head(int i) { 5806 return getRuleContext(HeadContext.class,i); 5807 } 5808 public List<HtmlContext> html() { 5809 return getRuleContexts(HtmlContext.class); 5810 } 5811 public HtmlContext html(int i) { 5812 return getRuleContext(HtmlContext.class,i); 5813 } 5814 public List<OptionContext> option() { 5815 return getRuleContexts(OptionContext.class); 5816 } 5817 public OptionContext option(int i) { 5818 return getRuleContext(OptionContext.class,i); 5819 } 5820 public List<TbodyContext> tbody() { 5821 return getRuleContexts(TbodyContext.class); 5822 } 5823 public TbodyContext tbody(int i) { 5824 return getRuleContext(TbodyContext.class,i); 5825 } 5826 public List<TheadContext> thead() { 5827 return getRuleContexts(TheadContext.class); 5828 } 5829 public TheadContext thead(int i) { 5830 return getRuleContext(TheadContext.class,i); 5831 } 5832 public List<TfootContext> tfoot() { 5833 return getRuleContexts(TfootContext.class); 5834 } 5835 public TfootContext tfoot(int i) { 5836 return getRuleContext(TfootContext.class,i); 5837 } 5838 public List<PTagOpenContext> pTagOpen() { 5839 return getRuleContexts(PTagOpenContext.class); 5840 } 5841 public PTagOpenContext pTagOpen(int i) { 5842 return getRuleContext(PTagOpenContext.class,i); 5843 } 5844 public List<LiTagOpenContext> liTagOpen() { 5845 return getRuleContexts(LiTagOpenContext.class); 5846 } 5847 public LiTagOpenContext liTagOpen(int i) { 5848 return getRuleContext(LiTagOpenContext.class,i); 5849 } 5850 public List<TrTagOpenContext> trTagOpen() { 5851 return getRuleContexts(TrTagOpenContext.class); 5852 } 5853 public TrTagOpenContext trTagOpen(int i) { 5854 return getRuleContext(TrTagOpenContext.class,i); 5855 } 5856 public List<TdTagOpenContext> tdTagOpen() { 5857 return getRuleContexts(TdTagOpenContext.class); 5858 } 5859 public TdTagOpenContext tdTagOpen(int i) { 5860 return getRuleContext(TdTagOpenContext.class,i); 5861 } 5862 public List<ThTagOpenContext> thTagOpen() { 5863 return getRuleContexts(ThTagOpenContext.class); 5864 } 5865 public ThTagOpenContext thTagOpen(int i) { 5866 return getRuleContext(ThTagOpenContext.class,i); 5867 } 5868 public List<BodyTagOpenContext> bodyTagOpen() { 5869 return getRuleContexts(BodyTagOpenContext.class); 5870 } 5871 public BodyTagOpenContext bodyTagOpen(int i) { 5872 return getRuleContext(BodyTagOpenContext.class,i); 5873 } 5874 public List<DdTagOpenContext> ddTagOpen() { 5875 return getRuleContexts(DdTagOpenContext.class); 5876 } 5877 public DdTagOpenContext ddTagOpen(int i) { 5878 return getRuleContext(DdTagOpenContext.class,i); 5879 } 5880 public List<DtTagOpenContext> dtTagOpen() { 5881 return getRuleContexts(DtTagOpenContext.class); 5882 } 5883 public DtTagOpenContext dtTagOpen(int i) { 5884 return getRuleContext(DtTagOpenContext.class,i); 5885 } 5886 public List<HeadTagOpenContext> headTagOpen() { 5887 return getRuleContexts(HeadTagOpenContext.class); 5888 } 5889 public HeadTagOpenContext headTagOpen(int i) { 5890 return getRuleContext(HeadTagOpenContext.class,i); 5891 } 5892 public List<HtmlTagOpenContext> htmlTagOpen() { 5893 return getRuleContexts(HtmlTagOpenContext.class); 5894 } 5895 public HtmlTagOpenContext htmlTagOpen(int i) { 5896 return getRuleContext(HtmlTagOpenContext.class,i); 5897 } 5898 public List<OptionTagOpenContext> optionTagOpen() { 5899 return getRuleContexts(OptionTagOpenContext.class); 5900 } 5901 public OptionTagOpenContext optionTagOpen(int i) { 5902 return getRuleContext(OptionTagOpenContext.class,i); 5903 } 5904 public List<TbodyTagOpenContext> tbodyTagOpen() { 5905 return getRuleContexts(TbodyTagOpenContext.class); 5906 } 5907 public TbodyTagOpenContext tbodyTagOpen(int i) { 5908 return getRuleContext(TbodyTagOpenContext.class,i); 5909 } 5910 public List<TheadTagOpenContext> theadTagOpen() { 5911 return getRuleContexts(TheadTagOpenContext.class); 5912 } 5913 public TheadTagOpenContext theadTagOpen(int i) { 5914 return getRuleContext(TheadTagOpenContext.class,i); 5915 } 5916 public List<TfootTagOpenContext> tfootTagOpen() { 5917 return getRuleContexts(TfootTagOpenContext.class); 5918 } 5919 public TfootTagOpenContext tfootTagOpen(int i) { 5920 return getRuleContext(TfootTagOpenContext.class,i); 5921 } 5922 public List<HtmlCommentContext> htmlComment() { 5923 return getRuleContexts(HtmlCommentContext.class); 5924 } 5925 public HtmlCommentContext htmlComment(int i) { 5926 return getRuleContext(HtmlCommentContext.class,i); 5927 } 5928 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5929 public TerminalNode CDATA(int i) { 5930 return getToken(JavadocParser.CDATA, i); 5931 } 5932 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5933 public TerminalNode NEWLINE(int i) { 5934 return getToken(JavadocParser.NEWLINE, i); 5935 } 5936 public List<TextContext> text() { 5937 return getRuleContexts(TextContext.class); 5938 } 5939 public TextContext text(int i) { 5940 return getRuleContext(TextContext.class,i); 5941 } 5942 public List<JavadocInlineTagContext> javadocInlineTag() { 5943 return getRuleContexts(JavadocInlineTagContext.class); 5944 } 5945 public JavadocInlineTagContext javadocInlineTag(int i) { 5946 return getRuleContext(JavadocInlineTagContext.class,i); 5947 } 5948 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5949 public TerminalNode LEADING_ASTERISK(int i) { 5950 return getToken(JavadocParser.LEADING_ASTERISK, i); 5951 } 5952 public ColgroupContext(ParserRuleContext parent, int invokingState) { 5953 super(parent, invokingState); 5954 } 5955 @Override public int getRuleIndex() { return RULE_colgroup; } 5956 @Override 5957 public void enterRule(ParseTreeListener listener) { 5958 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroup(this); 5959 } 5960 @Override 5961 public void exitRule(ParseTreeListener listener) { 5962 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroup(this); 5963 } 5964 @Override 5965 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5966 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroup(this); 5967 else return visitor.visitChildren(this); 5968 } 5969 } 5970 5971 public final ColgroupContext colgroup() throws RecognitionException { 5972 ColgroupContext _localctx = new ColgroupContext(_ctx, getState()); 5973 enterRule(_localctx, 52, RULE_colgroup); 5974 try { 5975 int _alt; 5976 enterOuterAlt(_localctx, 1); 5977 { 5978 setState(744); 5979 colgroupTagOpen(); 5980 setState(784); 5981 _errHandler.sync(this); 5982 _alt = getInterpreter().adaptivePredict(_input,51,_ctx); 5983 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5984 if ( _alt==1 ) { 5985 { 5986 setState(782); 5987 _errHandler.sync(this); 5988 switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { 5989 case 1: 5990 { 5991 setState(745); 5992 htmlTag(); 5993 } 5994 break; 5995 case 2: 5996 { 5997 setState(746); 5998 singletonTag(); 5999 } 6000 break; 6001 case 3: 6002 { 6003 setState(747); 6004 paragraph(); 6005 } 6006 break; 6007 case 4: 6008 { 6009 setState(748); 6010 li(); 6011 } 6012 break; 6013 case 5: 6014 { 6015 setState(749); 6016 tr(); 6017 } 6018 break; 6019 case 6: 6020 { 6021 setState(750); 6022 td(); 6023 } 6024 break; 6025 case 7: 6026 { 6027 setState(751); 6028 th(); 6029 } 6030 break; 6031 case 8: 6032 { 6033 setState(752); 6034 body(); 6035 } 6036 break; 6037 case 9: 6038 { 6039 setState(753); 6040 dd(); 6041 } 6042 break; 6043 case 10: 6044 { 6045 setState(754); 6046 dt(); 6047 } 6048 break; 6049 case 11: 6050 { 6051 setState(755); 6052 head(); 6053 } 6054 break; 6055 case 12: 6056 { 6057 setState(756); 6058 html(); 6059 } 6060 break; 6061 case 13: 6062 { 6063 setState(757); 6064 option(); 6065 } 6066 break; 6067 case 14: 6068 { 6069 setState(758); 6070 tbody(); 6071 } 6072 break; 6073 case 15: 6074 { 6075 setState(759); 6076 thead(); 6077 } 6078 break; 6079 case 16: 6080 { 6081 setState(760); 6082 tfoot(); 6083 } 6084 break; 6085 case 17: 6086 { 6087 setState(761); 6088 pTagOpen(); 6089 } 6090 break; 6091 case 18: 6092 { 6093 setState(762); 6094 liTagOpen(); 6095 } 6096 break; 6097 case 19: 6098 { 6099 setState(763); 6100 trTagOpen(); 6101 } 6102 break; 6103 case 20: 6104 { 6105 setState(764); 6106 tdTagOpen(); 6107 } 6108 break; 6109 case 21: 6110 { 6111 setState(765); 6112 thTagOpen(); 6113 } 6114 break; 6115 case 22: 6116 { 6117 setState(766); 6118 bodyTagOpen(); 6119 } 6120 break; 6121 case 23: 6122 { 6123 setState(767); 6124 ddTagOpen(); 6125 } 6126 break; 6127 case 24: 6128 { 6129 setState(768); 6130 dtTagOpen(); 6131 } 6132 break; 6133 case 25: 6134 { 6135 setState(769); 6136 headTagOpen(); 6137 } 6138 break; 6139 case 26: 6140 { 6141 setState(770); 6142 htmlTagOpen(); 6143 } 6144 break; 6145 case 27: 6146 { 6147 setState(771); 6148 optionTagOpen(); 6149 } 6150 break; 6151 case 28: 6152 { 6153 setState(772); 6154 tbodyTagOpen(); 6155 } 6156 break; 6157 case 29: 6158 { 6159 setState(773); 6160 theadTagOpen(); 6161 } 6162 break; 6163 case 30: 6164 { 6165 setState(774); 6166 tfootTagOpen(); 6167 } 6168 break; 6169 case 31: 6170 { 6171 { 6172 setState(775); 6173 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6174 setState(776); 6175 match(LEADING_ASTERISK); 6176 } 6177 } 6178 break; 6179 case 32: 6180 { 6181 setState(777); 6182 htmlComment(); 6183 } 6184 break; 6185 case 33: 6186 { 6187 setState(778); 6188 match(CDATA); 6189 } 6190 break; 6191 case 34: 6192 { 6193 setState(779); 6194 match(NEWLINE); 6195 } 6196 break; 6197 case 35: 6198 { 6199 setState(780); 6200 text(); 6201 } 6202 break; 6203 case 36: 6204 { 6205 setState(781); 6206 javadocInlineTag(); 6207 } 6208 break; 6209 } 6210 } 6211 } 6212 setState(786); 6213 _errHandler.sync(this); 6214 _alt = getInterpreter().adaptivePredict(_input,51,_ctx); 6215 } 6216 setState(787); 6217 colgroupTagClose(); 6218 } 6219 } 6220 catch (RecognitionException re) { 6221 _localctx.exception = re; 6222 _errHandler.reportError(this, re); 6223 _errHandler.recover(this, re); 6224 } 6225 finally { 6226 exitRule(); 6227 } 6228 return _localctx; 6229 } 6230 6231 public static class DdTagOpenContext extends ParserRuleContext { 6232 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6233 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6234 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6235 public List<AttributeContext> attribute() { 6236 return getRuleContexts(AttributeContext.class); 6237 } 6238 public AttributeContext attribute(int i) { 6239 return getRuleContext(AttributeContext.class,i); 6240 } 6241 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6242 public TerminalNode NEWLINE(int i) { 6243 return getToken(JavadocParser.NEWLINE, i); 6244 } 6245 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6246 public TerminalNode LEADING_ASTERISK(int i) { 6247 return getToken(JavadocParser.LEADING_ASTERISK, i); 6248 } 6249 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6250 public TerminalNode WS(int i) { 6251 return getToken(JavadocParser.WS, i); 6252 } 6253 public DdTagOpenContext(ParserRuleContext parent, int invokingState) { 6254 super(parent, invokingState); 6255 } 6256 @Override public int getRuleIndex() { return RULE_ddTagOpen; } 6257 @Override 6258 public void enterRule(ParseTreeListener listener) { 6259 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagOpen(this); 6260 } 6261 @Override 6262 public void exitRule(ParseTreeListener listener) { 6263 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagOpen(this); 6264 } 6265 @Override 6266 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6267 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagOpen(this); 6268 else return visitor.visitChildren(this); 6269 } 6270 } 6271 6272 public final DdTagOpenContext ddTagOpen() throws RecognitionException { 6273 DdTagOpenContext _localctx = new DdTagOpenContext(_ctx, getState()); 6274 enterRule(_localctx, 54, RULE_ddTagOpen); 6275 int _la; 6276 try { 6277 enterOuterAlt(_localctx, 1); 6278 { 6279 setState(789); 6280 match(OPEN); 6281 setState(790); 6282 match(DD_HTML_TAG_NAME); 6283 setState(797); 6284 _errHandler.sync(this); 6285 _la = _input.LA(1); 6286 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6287 { 6288 setState(795); 6289 switch (_input.LA(1)) { 6290 case HTML_TAG_NAME: 6291 { 6292 setState(791); 6293 attribute(); 6294 } 6295 break; 6296 case NEWLINE: 6297 { 6298 setState(792); 6299 match(NEWLINE); 6300 } 6301 break; 6302 case LEADING_ASTERISK: 6303 { 6304 setState(793); 6305 match(LEADING_ASTERISK); 6306 } 6307 break; 6308 case WS: 6309 { 6310 setState(794); 6311 match(WS); 6312 } 6313 break; 6314 default: 6315 throw new NoViableAltException(this); 6316 } 6317 } 6318 setState(799); 6319 _errHandler.sync(this); 6320 _la = _input.LA(1); 6321 } 6322 setState(800); 6323 match(CLOSE); 6324 } 6325 } 6326 catch (RecognitionException re) { 6327 _localctx.exception = re; 6328 _errHandler.reportError(this, re); 6329 _errHandler.recover(this, re); 6330 } 6331 finally { 6332 exitRule(); 6333 } 6334 return _localctx; 6335 } 6336 6337 public static class DdTagCloseContext extends ParserRuleContext { 6338 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6339 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 6340 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6341 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6342 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6343 public TerminalNode NEWLINE(int i) { 6344 return getToken(JavadocParser.NEWLINE, i); 6345 } 6346 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6347 public TerminalNode LEADING_ASTERISK(int i) { 6348 return getToken(JavadocParser.LEADING_ASTERISK, i); 6349 } 6350 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6351 public TerminalNode WS(int i) { 6352 return getToken(JavadocParser.WS, i); 6353 } 6354 public DdTagCloseContext(ParserRuleContext parent, int invokingState) { 6355 super(parent, invokingState); 6356 } 6357 @Override public int getRuleIndex() { return RULE_ddTagClose; } 6358 @Override 6359 public void enterRule(ParseTreeListener listener) { 6360 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagClose(this); 6361 } 6362 @Override 6363 public void exitRule(ParseTreeListener listener) { 6364 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagClose(this); 6365 } 6366 @Override 6367 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6368 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagClose(this); 6369 else return visitor.visitChildren(this); 6370 } 6371 } 6372 6373 public final DdTagCloseContext ddTagClose() throws RecognitionException { 6374 DdTagCloseContext _localctx = new DdTagCloseContext(_ctx, getState()); 6375 enterRule(_localctx, 56, RULE_ddTagClose); 6376 int _la; 6377 try { 6378 enterOuterAlt(_localctx, 1); 6379 { 6380 setState(802); 6381 match(OPEN); 6382 setState(803); 6383 match(SLASH); 6384 setState(804); 6385 match(DD_HTML_TAG_NAME); 6386 setState(808); 6387 _errHandler.sync(this); 6388 _la = _input.LA(1); 6389 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 6390 { 6391 { 6392 setState(805); 6393 _la = _input.LA(1); 6394 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 6395 _errHandler.recoverInline(this); 6396 } else { 6397 consume(); 6398 } 6399 } 6400 } 6401 setState(810); 6402 _errHandler.sync(this); 6403 _la = _input.LA(1); 6404 } 6405 setState(811); 6406 match(CLOSE); 6407 } 6408 } 6409 catch (RecognitionException re) { 6410 _localctx.exception = re; 6411 _errHandler.reportError(this, re); 6412 _errHandler.recover(this, re); 6413 } 6414 finally { 6415 exitRule(); 6416 } 6417 return _localctx; 6418 } 6419 6420 public static class DdContext extends ParserRuleContext { 6421 public DdTagOpenContext ddTagOpen() { 6422 return getRuleContext(DdTagOpenContext.class,0); 6423 } 6424 public DdTagCloseContext ddTagClose() { 6425 return getRuleContext(DdTagCloseContext.class,0); 6426 } 6427 public List<HtmlTagContext> htmlTag() { 6428 return getRuleContexts(HtmlTagContext.class); 6429 } 6430 public HtmlTagContext htmlTag(int i) { 6431 return getRuleContext(HtmlTagContext.class,i); 6432 } 6433 public List<SingletonTagContext> singletonTag() { 6434 return getRuleContexts(SingletonTagContext.class); 6435 } 6436 public SingletonTagContext singletonTag(int i) { 6437 return getRuleContext(SingletonTagContext.class,i); 6438 } 6439 public List<ParagraphContext> paragraph() { 6440 return getRuleContexts(ParagraphContext.class); 6441 } 6442 public ParagraphContext paragraph(int i) { 6443 return getRuleContext(ParagraphContext.class,i); 6444 } 6445 public List<LiContext> li() { 6446 return getRuleContexts(LiContext.class); 6447 } 6448 public LiContext li(int i) { 6449 return getRuleContext(LiContext.class,i); 6450 } 6451 public List<TrContext> tr() { 6452 return getRuleContexts(TrContext.class); 6453 } 6454 public TrContext tr(int i) { 6455 return getRuleContext(TrContext.class,i); 6456 } 6457 public List<TdContext> td() { 6458 return getRuleContexts(TdContext.class); 6459 } 6460 public TdContext td(int i) { 6461 return getRuleContext(TdContext.class,i); 6462 } 6463 public List<ThContext> th() { 6464 return getRuleContexts(ThContext.class); 6465 } 6466 public ThContext th(int i) { 6467 return getRuleContext(ThContext.class,i); 6468 } 6469 public List<BodyContext> body() { 6470 return getRuleContexts(BodyContext.class); 6471 } 6472 public BodyContext body(int i) { 6473 return getRuleContext(BodyContext.class,i); 6474 } 6475 public List<ColgroupContext> colgroup() { 6476 return getRuleContexts(ColgroupContext.class); 6477 } 6478 public ColgroupContext colgroup(int i) { 6479 return getRuleContext(ColgroupContext.class,i); 6480 } 6481 public List<DtContext> dt() { 6482 return getRuleContexts(DtContext.class); 6483 } 6484 public DtContext dt(int i) { 6485 return getRuleContext(DtContext.class,i); 6486 } 6487 public List<HeadContext> head() { 6488 return getRuleContexts(HeadContext.class); 6489 } 6490 public HeadContext head(int i) { 6491 return getRuleContext(HeadContext.class,i); 6492 } 6493 public List<HtmlContext> html() { 6494 return getRuleContexts(HtmlContext.class); 6495 } 6496 public HtmlContext html(int i) { 6497 return getRuleContext(HtmlContext.class,i); 6498 } 6499 public List<OptionContext> option() { 6500 return getRuleContexts(OptionContext.class); 6501 } 6502 public OptionContext option(int i) { 6503 return getRuleContext(OptionContext.class,i); 6504 } 6505 public List<TbodyContext> tbody() { 6506 return getRuleContexts(TbodyContext.class); 6507 } 6508 public TbodyContext tbody(int i) { 6509 return getRuleContext(TbodyContext.class,i); 6510 } 6511 public List<TheadContext> thead() { 6512 return getRuleContexts(TheadContext.class); 6513 } 6514 public TheadContext thead(int i) { 6515 return getRuleContext(TheadContext.class,i); 6516 } 6517 public List<TfootContext> tfoot() { 6518 return getRuleContexts(TfootContext.class); 6519 } 6520 public TfootContext tfoot(int i) { 6521 return getRuleContext(TfootContext.class,i); 6522 } 6523 public List<PTagOpenContext> pTagOpen() { 6524 return getRuleContexts(PTagOpenContext.class); 6525 } 6526 public PTagOpenContext pTagOpen(int i) { 6527 return getRuleContext(PTagOpenContext.class,i); 6528 } 6529 public List<LiTagOpenContext> liTagOpen() { 6530 return getRuleContexts(LiTagOpenContext.class); 6531 } 6532 public LiTagOpenContext liTagOpen(int i) { 6533 return getRuleContext(LiTagOpenContext.class,i); 6534 } 6535 public List<TrTagOpenContext> trTagOpen() { 6536 return getRuleContexts(TrTagOpenContext.class); 6537 } 6538 public TrTagOpenContext trTagOpen(int i) { 6539 return getRuleContext(TrTagOpenContext.class,i); 6540 } 6541 public List<TdTagOpenContext> tdTagOpen() { 6542 return getRuleContexts(TdTagOpenContext.class); 6543 } 6544 public TdTagOpenContext tdTagOpen(int i) { 6545 return getRuleContext(TdTagOpenContext.class,i); 6546 } 6547 public List<ThTagOpenContext> thTagOpen() { 6548 return getRuleContexts(ThTagOpenContext.class); 6549 } 6550 public ThTagOpenContext thTagOpen(int i) { 6551 return getRuleContext(ThTagOpenContext.class,i); 6552 } 6553 public List<BodyTagOpenContext> bodyTagOpen() { 6554 return getRuleContexts(BodyTagOpenContext.class); 6555 } 6556 public BodyTagOpenContext bodyTagOpen(int i) { 6557 return getRuleContext(BodyTagOpenContext.class,i); 6558 } 6559 public List<ColgroupTagOpenContext> colgroupTagOpen() { 6560 return getRuleContexts(ColgroupTagOpenContext.class); 6561 } 6562 public ColgroupTagOpenContext colgroupTagOpen(int i) { 6563 return getRuleContext(ColgroupTagOpenContext.class,i); 6564 } 6565 public List<DtTagOpenContext> dtTagOpen() { 6566 return getRuleContexts(DtTagOpenContext.class); 6567 } 6568 public DtTagOpenContext dtTagOpen(int i) { 6569 return getRuleContext(DtTagOpenContext.class,i); 6570 } 6571 public List<HeadTagOpenContext> headTagOpen() { 6572 return getRuleContexts(HeadTagOpenContext.class); 6573 } 6574 public HeadTagOpenContext headTagOpen(int i) { 6575 return getRuleContext(HeadTagOpenContext.class,i); 6576 } 6577 public List<HtmlTagOpenContext> htmlTagOpen() { 6578 return getRuleContexts(HtmlTagOpenContext.class); 6579 } 6580 public HtmlTagOpenContext htmlTagOpen(int i) { 6581 return getRuleContext(HtmlTagOpenContext.class,i); 6582 } 6583 public List<OptionTagOpenContext> optionTagOpen() { 6584 return getRuleContexts(OptionTagOpenContext.class); 6585 } 6586 public OptionTagOpenContext optionTagOpen(int i) { 6587 return getRuleContext(OptionTagOpenContext.class,i); 6588 } 6589 public List<TbodyTagOpenContext> tbodyTagOpen() { 6590 return getRuleContexts(TbodyTagOpenContext.class); 6591 } 6592 public TbodyTagOpenContext tbodyTagOpen(int i) { 6593 return getRuleContext(TbodyTagOpenContext.class,i); 6594 } 6595 public List<TheadTagOpenContext> theadTagOpen() { 6596 return getRuleContexts(TheadTagOpenContext.class); 6597 } 6598 public TheadTagOpenContext theadTagOpen(int i) { 6599 return getRuleContext(TheadTagOpenContext.class,i); 6600 } 6601 public List<TfootTagOpenContext> tfootTagOpen() { 6602 return getRuleContexts(TfootTagOpenContext.class); 6603 } 6604 public TfootTagOpenContext tfootTagOpen(int i) { 6605 return getRuleContext(TfootTagOpenContext.class,i); 6606 } 6607 public List<HtmlCommentContext> htmlComment() { 6608 return getRuleContexts(HtmlCommentContext.class); 6609 } 6610 public HtmlCommentContext htmlComment(int i) { 6611 return getRuleContext(HtmlCommentContext.class,i); 6612 } 6613 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 6614 public TerminalNode CDATA(int i) { 6615 return getToken(JavadocParser.CDATA, i); 6616 } 6617 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6618 public TerminalNode NEWLINE(int i) { 6619 return getToken(JavadocParser.NEWLINE, i); 6620 } 6621 public List<TextContext> text() { 6622 return getRuleContexts(TextContext.class); 6623 } 6624 public TextContext text(int i) { 6625 return getRuleContext(TextContext.class,i); 6626 } 6627 public List<JavadocInlineTagContext> javadocInlineTag() { 6628 return getRuleContexts(JavadocInlineTagContext.class); 6629 } 6630 public JavadocInlineTagContext javadocInlineTag(int i) { 6631 return getRuleContext(JavadocInlineTagContext.class,i); 6632 } 6633 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6634 public TerminalNode LEADING_ASTERISK(int i) { 6635 return getToken(JavadocParser.LEADING_ASTERISK, i); 6636 } 6637 public DdContext(ParserRuleContext parent, int invokingState) { 6638 super(parent, invokingState); 6639 } 6640 @Override public int getRuleIndex() { return RULE_dd; } 6641 @Override 6642 public void enterRule(ParseTreeListener listener) { 6643 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDd(this); 6644 } 6645 @Override 6646 public void exitRule(ParseTreeListener listener) { 6647 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDd(this); 6648 } 6649 @Override 6650 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6651 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDd(this); 6652 else return visitor.visitChildren(this); 6653 } 6654 } 6655 6656 public final DdContext dd() throws RecognitionException { 6657 DdContext _localctx = new DdContext(_ctx, getState()); 6658 enterRule(_localctx, 58, RULE_dd); 6659 try { 6660 int _alt; 6661 enterOuterAlt(_localctx, 1); 6662 { 6663 setState(813); 6664 ddTagOpen(); 6665 setState(853); 6666 _errHandler.sync(this); 6667 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6668 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6669 if ( _alt==1 ) { 6670 { 6671 setState(851); 6672 _errHandler.sync(this); 6673 switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { 6674 case 1: 6675 { 6676 setState(814); 6677 htmlTag(); 6678 } 6679 break; 6680 case 2: 6681 { 6682 setState(815); 6683 singletonTag(); 6684 } 6685 break; 6686 case 3: 6687 { 6688 setState(816); 6689 paragraph(); 6690 } 6691 break; 6692 case 4: 6693 { 6694 setState(817); 6695 li(); 6696 } 6697 break; 6698 case 5: 6699 { 6700 setState(818); 6701 tr(); 6702 } 6703 break; 6704 case 6: 6705 { 6706 setState(819); 6707 td(); 6708 } 6709 break; 6710 case 7: 6711 { 6712 setState(820); 6713 th(); 6714 } 6715 break; 6716 case 8: 6717 { 6718 setState(821); 6719 body(); 6720 } 6721 break; 6722 case 9: 6723 { 6724 setState(822); 6725 colgroup(); 6726 } 6727 break; 6728 case 10: 6729 { 6730 setState(823); 6731 dt(); 6732 } 6733 break; 6734 case 11: 6735 { 6736 setState(824); 6737 head(); 6738 } 6739 break; 6740 case 12: 6741 { 6742 setState(825); 6743 html(); 6744 } 6745 break; 6746 case 13: 6747 { 6748 setState(826); 6749 option(); 6750 } 6751 break; 6752 case 14: 6753 { 6754 setState(827); 6755 tbody(); 6756 } 6757 break; 6758 case 15: 6759 { 6760 setState(828); 6761 thead(); 6762 } 6763 break; 6764 case 16: 6765 { 6766 setState(829); 6767 tfoot(); 6768 } 6769 break; 6770 case 17: 6771 { 6772 setState(830); 6773 pTagOpen(); 6774 } 6775 break; 6776 case 18: 6777 { 6778 setState(831); 6779 liTagOpen(); 6780 } 6781 break; 6782 case 19: 6783 { 6784 setState(832); 6785 trTagOpen(); 6786 } 6787 break; 6788 case 20: 6789 { 6790 setState(833); 6791 tdTagOpen(); 6792 } 6793 break; 6794 case 21: 6795 { 6796 setState(834); 6797 thTagOpen(); 6798 } 6799 break; 6800 case 22: 6801 { 6802 setState(835); 6803 bodyTagOpen(); 6804 } 6805 break; 6806 case 23: 6807 { 6808 setState(836); 6809 colgroupTagOpen(); 6810 } 6811 break; 6812 case 24: 6813 { 6814 setState(837); 6815 dtTagOpen(); 6816 } 6817 break; 6818 case 25: 6819 { 6820 setState(838); 6821 headTagOpen(); 6822 } 6823 break; 6824 case 26: 6825 { 6826 setState(839); 6827 htmlTagOpen(); 6828 } 6829 break; 6830 case 27: 6831 { 6832 setState(840); 6833 optionTagOpen(); 6834 } 6835 break; 6836 case 28: 6837 { 6838 setState(841); 6839 tbodyTagOpen(); 6840 } 6841 break; 6842 case 29: 6843 { 6844 setState(842); 6845 theadTagOpen(); 6846 } 6847 break; 6848 case 30: 6849 { 6850 setState(843); 6851 tfootTagOpen(); 6852 } 6853 break; 6854 case 31: 6855 { 6856 { 6857 setState(844); 6858 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6859 setState(845); 6860 match(LEADING_ASTERISK); 6861 } 6862 } 6863 break; 6864 case 32: 6865 { 6866 setState(846); 6867 htmlComment(); 6868 } 6869 break; 6870 case 33: 6871 { 6872 setState(847); 6873 match(CDATA); 6874 } 6875 break; 6876 case 34: 6877 { 6878 setState(848); 6879 match(NEWLINE); 6880 } 6881 break; 6882 case 35: 6883 { 6884 setState(849); 6885 text(); 6886 } 6887 break; 6888 case 36: 6889 { 6890 setState(850); 6891 javadocInlineTag(); 6892 } 6893 break; 6894 } 6895 } 6896 } 6897 setState(855); 6898 _errHandler.sync(this); 6899 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6900 } 6901 setState(856); 6902 ddTagClose(); 6903 } 6904 } 6905 catch (RecognitionException re) { 6906 _localctx.exception = re; 6907 _errHandler.reportError(this, re); 6908 _errHandler.recover(this, re); 6909 } 6910 finally { 6911 exitRule(); 6912 } 6913 return _localctx; 6914 } 6915 6916 public static class DtTagOpenContext extends ParserRuleContext { 6917 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6918 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 6919 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6920 public List<AttributeContext> attribute() { 6921 return getRuleContexts(AttributeContext.class); 6922 } 6923 public AttributeContext attribute(int i) { 6924 return getRuleContext(AttributeContext.class,i); 6925 } 6926 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6927 public TerminalNode NEWLINE(int i) { 6928 return getToken(JavadocParser.NEWLINE, i); 6929 } 6930 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6931 public TerminalNode LEADING_ASTERISK(int i) { 6932 return getToken(JavadocParser.LEADING_ASTERISK, i); 6933 } 6934 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6935 public TerminalNode WS(int i) { 6936 return getToken(JavadocParser.WS, i); 6937 } 6938 public DtTagOpenContext(ParserRuleContext parent, int invokingState) { 6939 super(parent, invokingState); 6940 } 6941 @Override public int getRuleIndex() { return RULE_dtTagOpen; } 6942 @Override 6943 public void enterRule(ParseTreeListener listener) { 6944 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagOpen(this); 6945 } 6946 @Override 6947 public void exitRule(ParseTreeListener listener) { 6948 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagOpen(this); 6949 } 6950 @Override 6951 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6952 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagOpen(this); 6953 else return visitor.visitChildren(this); 6954 } 6955 } 6956 6957 public final DtTagOpenContext dtTagOpen() throws RecognitionException { 6958 DtTagOpenContext _localctx = new DtTagOpenContext(_ctx, getState()); 6959 enterRule(_localctx, 60, RULE_dtTagOpen); 6960 int _la; 6961 try { 6962 enterOuterAlt(_localctx, 1); 6963 { 6964 setState(858); 6965 match(OPEN); 6966 setState(859); 6967 match(DT_HTML_TAG_NAME); 6968 setState(866); 6969 _errHandler.sync(this); 6970 _la = _input.LA(1); 6971 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6972 { 6973 setState(864); 6974 switch (_input.LA(1)) { 6975 case HTML_TAG_NAME: 6976 { 6977 setState(860); 6978 attribute(); 6979 } 6980 break; 6981 case NEWLINE: 6982 { 6983 setState(861); 6984 match(NEWLINE); 6985 } 6986 break; 6987 case LEADING_ASTERISK: 6988 { 6989 setState(862); 6990 match(LEADING_ASTERISK); 6991 } 6992 break; 6993 case WS: 6994 { 6995 setState(863); 6996 match(WS); 6997 } 6998 break; 6999 default: 7000 throw new NoViableAltException(this); 7001 } 7002 } 7003 setState(868); 7004 _errHandler.sync(this); 7005 _la = _input.LA(1); 7006 } 7007 setState(869); 7008 match(CLOSE); 7009 } 7010 } 7011 catch (RecognitionException re) { 7012 _localctx.exception = re; 7013 _errHandler.reportError(this, re); 7014 _errHandler.recover(this, re); 7015 } 7016 finally { 7017 exitRule(); 7018 } 7019 return _localctx; 7020 } 7021 7022 public static class DtTagCloseContext extends ParserRuleContext { 7023 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7024 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7025 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 7026 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7027 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7028 public TerminalNode NEWLINE(int i) { 7029 return getToken(JavadocParser.NEWLINE, i); 7030 } 7031 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7032 public TerminalNode LEADING_ASTERISK(int i) { 7033 return getToken(JavadocParser.LEADING_ASTERISK, i); 7034 } 7035 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7036 public TerminalNode WS(int i) { 7037 return getToken(JavadocParser.WS, i); 7038 } 7039 public DtTagCloseContext(ParserRuleContext parent, int invokingState) { 7040 super(parent, invokingState); 7041 } 7042 @Override public int getRuleIndex() { return RULE_dtTagClose; } 7043 @Override 7044 public void enterRule(ParseTreeListener listener) { 7045 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagClose(this); 7046 } 7047 @Override 7048 public void exitRule(ParseTreeListener listener) { 7049 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagClose(this); 7050 } 7051 @Override 7052 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7053 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagClose(this); 7054 else return visitor.visitChildren(this); 7055 } 7056 } 7057 7058 public final DtTagCloseContext dtTagClose() throws RecognitionException { 7059 DtTagCloseContext _localctx = new DtTagCloseContext(_ctx, getState()); 7060 enterRule(_localctx, 62, RULE_dtTagClose); 7061 int _la; 7062 try { 7063 enterOuterAlt(_localctx, 1); 7064 { 7065 setState(871); 7066 match(OPEN); 7067 setState(872); 7068 match(SLASH); 7069 setState(873); 7070 match(DT_HTML_TAG_NAME); 7071 setState(877); 7072 _errHandler.sync(this); 7073 _la = _input.LA(1); 7074 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7075 { 7076 { 7077 setState(874); 7078 _la = _input.LA(1); 7079 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7080 _errHandler.recoverInline(this); 7081 } else { 7082 consume(); 7083 } 7084 } 7085 } 7086 setState(879); 7087 _errHandler.sync(this); 7088 _la = _input.LA(1); 7089 } 7090 setState(880); 7091 match(CLOSE); 7092 } 7093 } 7094 catch (RecognitionException re) { 7095 _localctx.exception = re; 7096 _errHandler.reportError(this, re); 7097 _errHandler.recover(this, re); 7098 } 7099 finally { 7100 exitRule(); 7101 } 7102 return _localctx; 7103 } 7104 7105 public static class DtContext extends ParserRuleContext { 7106 public DtTagOpenContext dtTagOpen() { 7107 return getRuleContext(DtTagOpenContext.class,0); 7108 } 7109 public DtTagCloseContext dtTagClose() { 7110 return getRuleContext(DtTagCloseContext.class,0); 7111 } 7112 public List<HtmlTagContext> htmlTag() { 7113 return getRuleContexts(HtmlTagContext.class); 7114 } 7115 public HtmlTagContext htmlTag(int i) { 7116 return getRuleContext(HtmlTagContext.class,i); 7117 } 7118 public List<SingletonTagContext> singletonTag() { 7119 return getRuleContexts(SingletonTagContext.class); 7120 } 7121 public SingletonTagContext singletonTag(int i) { 7122 return getRuleContext(SingletonTagContext.class,i); 7123 } 7124 public List<ParagraphContext> paragraph() { 7125 return getRuleContexts(ParagraphContext.class); 7126 } 7127 public ParagraphContext paragraph(int i) { 7128 return getRuleContext(ParagraphContext.class,i); 7129 } 7130 public List<LiContext> li() { 7131 return getRuleContexts(LiContext.class); 7132 } 7133 public LiContext li(int i) { 7134 return getRuleContext(LiContext.class,i); 7135 } 7136 public List<TrContext> tr() { 7137 return getRuleContexts(TrContext.class); 7138 } 7139 public TrContext tr(int i) { 7140 return getRuleContext(TrContext.class,i); 7141 } 7142 public List<TdContext> td() { 7143 return getRuleContexts(TdContext.class); 7144 } 7145 public TdContext td(int i) { 7146 return getRuleContext(TdContext.class,i); 7147 } 7148 public List<ThContext> th() { 7149 return getRuleContexts(ThContext.class); 7150 } 7151 public ThContext th(int i) { 7152 return getRuleContext(ThContext.class,i); 7153 } 7154 public List<BodyContext> body() { 7155 return getRuleContexts(BodyContext.class); 7156 } 7157 public BodyContext body(int i) { 7158 return getRuleContext(BodyContext.class,i); 7159 } 7160 public List<ColgroupContext> colgroup() { 7161 return getRuleContexts(ColgroupContext.class); 7162 } 7163 public ColgroupContext colgroup(int i) { 7164 return getRuleContext(ColgroupContext.class,i); 7165 } 7166 public List<DdContext> dd() { 7167 return getRuleContexts(DdContext.class); 7168 } 7169 public DdContext dd(int i) { 7170 return getRuleContext(DdContext.class,i); 7171 } 7172 public List<HeadContext> head() { 7173 return getRuleContexts(HeadContext.class); 7174 } 7175 public HeadContext head(int i) { 7176 return getRuleContext(HeadContext.class,i); 7177 } 7178 public List<HtmlContext> html() { 7179 return getRuleContexts(HtmlContext.class); 7180 } 7181 public HtmlContext html(int i) { 7182 return getRuleContext(HtmlContext.class,i); 7183 } 7184 public List<OptionContext> option() { 7185 return getRuleContexts(OptionContext.class); 7186 } 7187 public OptionContext option(int i) { 7188 return getRuleContext(OptionContext.class,i); 7189 } 7190 public List<TbodyContext> tbody() { 7191 return getRuleContexts(TbodyContext.class); 7192 } 7193 public TbodyContext tbody(int i) { 7194 return getRuleContext(TbodyContext.class,i); 7195 } 7196 public List<TheadContext> thead() { 7197 return getRuleContexts(TheadContext.class); 7198 } 7199 public TheadContext thead(int i) { 7200 return getRuleContext(TheadContext.class,i); 7201 } 7202 public List<TfootContext> tfoot() { 7203 return getRuleContexts(TfootContext.class); 7204 } 7205 public TfootContext tfoot(int i) { 7206 return getRuleContext(TfootContext.class,i); 7207 } 7208 public List<PTagOpenContext> pTagOpen() { 7209 return getRuleContexts(PTagOpenContext.class); 7210 } 7211 public PTagOpenContext pTagOpen(int i) { 7212 return getRuleContext(PTagOpenContext.class,i); 7213 } 7214 public List<LiTagOpenContext> liTagOpen() { 7215 return getRuleContexts(LiTagOpenContext.class); 7216 } 7217 public LiTagOpenContext liTagOpen(int i) { 7218 return getRuleContext(LiTagOpenContext.class,i); 7219 } 7220 public List<TrTagOpenContext> trTagOpen() { 7221 return getRuleContexts(TrTagOpenContext.class); 7222 } 7223 public TrTagOpenContext trTagOpen(int i) { 7224 return getRuleContext(TrTagOpenContext.class,i); 7225 } 7226 public List<TdTagOpenContext> tdTagOpen() { 7227 return getRuleContexts(TdTagOpenContext.class); 7228 } 7229 public TdTagOpenContext tdTagOpen(int i) { 7230 return getRuleContext(TdTagOpenContext.class,i); 7231 } 7232 public List<ThTagOpenContext> thTagOpen() { 7233 return getRuleContexts(ThTagOpenContext.class); 7234 } 7235 public ThTagOpenContext thTagOpen(int i) { 7236 return getRuleContext(ThTagOpenContext.class,i); 7237 } 7238 public List<BodyTagOpenContext> bodyTagOpen() { 7239 return getRuleContexts(BodyTagOpenContext.class); 7240 } 7241 public BodyTagOpenContext bodyTagOpen(int i) { 7242 return getRuleContext(BodyTagOpenContext.class,i); 7243 } 7244 public List<ColgroupTagOpenContext> colgroupTagOpen() { 7245 return getRuleContexts(ColgroupTagOpenContext.class); 7246 } 7247 public ColgroupTagOpenContext colgroupTagOpen(int i) { 7248 return getRuleContext(ColgroupTagOpenContext.class,i); 7249 } 7250 public List<DdTagOpenContext> ddTagOpen() { 7251 return getRuleContexts(DdTagOpenContext.class); 7252 } 7253 public DdTagOpenContext ddTagOpen(int i) { 7254 return getRuleContext(DdTagOpenContext.class,i); 7255 } 7256 public List<HeadTagOpenContext> headTagOpen() { 7257 return getRuleContexts(HeadTagOpenContext.class); 7258 } 7259 public HeadTagOpenContext headTagOpen(int i) { 7260 return getRuleContext(HeadTagOpenContext.class,i); 7261 } 7262 public List<HtmlTagOpenContext> htmlTagOpen() { 7263 return getRuleContexts(HtmlTagOpenContext.class); 7264 } 7265 public HtmlTagOpenContext htmlTagOpen(int i) { 7266 return getRuleContext(HtmlTagOpenContext.class,i); 7267 } 7268 public List<OptionTagOpenContext> optionTagOpen() { 7269 return getRuleContexts(OptionTagOpenContext.class); 7270 } 7271 public OptionTagOpenContext optionTagOpen(int i) { 7272 return getRuleContext(OptionTagOpenContext.class,i); 7273 } 7274 public List<TbodyTagOpenContext> tbodyTagOpen() { 7275 return getRuleContexts(TbodyTagOpenContext.class); 7276 } 7277 public TbodyTagOpenContext tbodyTagOpen(int i) { 7278 return getRuleContext(TbodyTagOpenContext.class,i); 7279 } 7280 public List<TheadTagOpenContext> theadTagOpen() { 7281 return getRuleContexts(TheadTagOpenContext.class); 7282 } 7283 public TheadTagOpenContext theadTagOpen(int i) { 7284 return getRuleContext(TheadTagOpenContext.class,i); 7285 } 7286 public List<TfootTagOpenContext> tfootTagOpen() { 7287 return getRuleContexts(TfootTagOpenContext.class); 7288 } 7289 public TfootTagOpenContext tfootTagOpen(int i) { 7290 return getRuleContext(TfootTagOpenContext.class,i); 7291 } 7292 public List<HtmlCommentContext> htmlComment() { 7293 return getRuleContexts(HtmlCommentContext.class); 7294 } 7295 public HtmlCommentContext htmlComment(int i) { 7296 return getRuleContext(HtmlCommentContext.class,i); 7297 } 7298 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 7299 public TerminalNode CDATA(int i) { 7300 return getToken(JavadocParser.CDATA, i); 7301 } 7302 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7303 public TerminalNode NEWLINE(int i) { 7304 return getToken(JavadocParser.NEWLINE, i); 7305 } 7306 public List<TextContext> text() { 7307 return getRuleContexts(TextContext.class); 7308 } 7309 public TextContext text(int i) { 7310 return getRuleContext(TextContext.class,i); 7311 } 7312 public List<JavadocInlineTagContext> javadocInlineTag() { 7313 return getRuleContexts(JavadocInlineTagContext.class); 7314 } 7315 public JavadocInlineTagContext javadocInlineTag(int i) { 7316 return getRuleContext(JavadocInlineTagContext.class,i); 7317 } 7318 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7319 public TerminalNode LEADING_ASTERISK(int i) { 7320 return getToken(JavadocParser.LEADING_ASTERISK, i); 7321 } 7322 public DtContext(ParserRuleContext parent, int invokingState) { 7323 super(parent, invokingState); 7324 } 7325 @Override public int getRuleIndex() { return RULE_dt; } 7326 @Override 7327 public void enterRule(ParseTreeListener listener) { 7328 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDt(this); 7329 } 7330 @Override 7331 public void exitRule(ParseTreeListener listener) { 7332 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDt(this); 7333 } 7334 @Override 7335 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7336 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDt(this); 7337 else return visitor.visitChildren(this); 7338 } 7339 } 7340 7341 public final DtContext dt() throws RecognitionException { 7342 DtContext _localctx = new DtContext(_ctx, getState()); 7343 enterRule(_localctx, 64, RULE_dt); 7344 try { 7345 int _alt; 7346 enterOuterAlt(_localctx, 1); 7347 { 7348 setState(882); 7349 dtTagOpen(); 7350 setState(922); 7351 _errHandler.sync(this); 7352 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 7353 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 7354 if ( _alt==1 ) { 7355 { 7356 setState(920); 7357 _errHandler.sync(this); 7358 switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { 7359 case 1: 7360 { 7361 setState(883); 7362 htmlTag(); 7363 } 7364 break; 7365 case 2: 7366 { 7367 setState(884); 7368 singletonTag(); 7369 } 7370 break; 7371 case 3: 7372 { 7373 setState(885); 7374 paragraph(); 7375 } 7376 break; 7377 case 4: 7378 { 7379 setState(886); 7380 li(); 7381 } 7382 break; 7383 case 5: 7384 { 7385 setState(887); 7386 tr(); 7387 } 7388 break; 7389 case 6: 7390 { 7391 setState(888); 7392 td(); 7393 } 7394 break; 7395 case 7: 7396 { 7397 setState(889); 7398 th(); 7399 } 7400 break; 7401 case 8: 7402 { 7403 setState(890); 7404 body(); 7405 } 7406 break; 7407 case 9: 7408 { 7409 setState(891); 7410 colgroup(); 7411 } 7412 break; 7413 case 10: 7414 { 7415 setState(892); 7416 dd(); 7417 } 7418 break; 7419 case 11: 7420 { 7421 setState(893); 7422 head(); 7423 } 7424 break; 7425 case 12: 7426 { 7427 setState(894); 7428 html(); 7429 } 7430 break; 7431 case 13: 7432 { 7433 setState(895); 7434 option(); 7435 } 7436 break; 7437 case 14: 7438 { 7439 setState(896); 7440 tbody(); 7441 } 7442 break; 7443 case 15: 7444 { 7445 setState(897); 7446 thead(); 7447 } 7448 break; 7449 case 16: 7450 { 7451 setState(898); 7452 tfoot(); 7453 } 7454 break; 7455 case 17: 7456 { 7457 setState(899); 7458 pTagOpen(); 7459 } 7460 break; 7461 case 18: 7462 { 7463 setState(900); 7464 liTagOpen(); 7465 } 7466 break; 7467 case 19: 7468 { 7469 setState(901); 7470 trTagOpen(); 7471 } 7472 break; 7473 case 20: 7474 { 7475 setState(902); 7476 tdTagOpen(); 7477 } 7478 break; 7479 case 21: 7480 { 7481 setState(903); 7482 thTagOpen(); 7483 } 7484 break; 7485 case 22: 7486 { 7487 setState(904); 7488 bodyTagOpen(); 7489 } 7490 break; 7491 case 23: 7492 { 7493 setState(905); 7494 colgroupTagOpen(); 7495 } 7496 break; 7497 case 24: 7498 { 7499 setState(906); 7500 ddTagOpen(); 7501 } 7502 break; 7503 case 25: 7504 { 7505 setState(907); 7506 headTagOpen(); 7507 } 7508 break; 7509 case 26: 7510 { 7511 setState(908); 7512 htmlTagOpen(); 7513 } 7514 break; 7515 case 27: 7516 { 7517 setState(909); 7518 optionTagOpen(); 7519 } 7520 break; 7521 case 28: 7522 { 7523 setState(910); 7524 tbodyTagOpen(); 7525 } 7526 break; 7527 case 29: 7528 { 7529 setState(911); 7530 theadTagOpen(); 7531 } 7532 break; 7533 case 30: 7534 { 7535 setState(912); 7536 tfootTagOpen(); 7537 } 7538 break; 7539 case 31: 7540 { 7541 { 7542 setState(913); 7543 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 7544 setState(914); 7545 match(LEADING_ASTERISK); 7546 } 7547 } 7548 break; 7549 case 32: 7550 { 7551 setState(915); 7552 htmlComment(); 7553 } 7554 break; 7555 case 33: 7556 { 7557 setState(916); 7558 match(CDATA); 7559 } 7560 break; 7561 case 34: 7562 { 7563 setState(917); 7564 match(NEWLINE); 7565 } 7566 break; 7567 case 35: 7568 { 7569 setState(918); 7570 text(); 7571 } 7572 break; 7573 case 36: 7574 { 7575 setState(919); 7576 javadocInlineTag(); 7577 } 7578 break; 7579 } 7580 } 7581 } 7582 setState(924); 7583 _errHandler.sync(this); 7584 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 7585 } 7586 setState(925); 7587 dtTagClose(); 7588 } 7589 } 7590 catch (RecognitionException re) { 7591 _localctx.exception = re; 7592 _errHandler.reportError(this, re); 7593 _errHandler.recover(this, re); 7594 } 7595 finally { 7596 exitRule(); 7597 } 7598 return _localctx; 7599 } 7600 7601 public static class HeadTagOpenContext extends ParserRuleContext { 7602 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7603 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7604 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7605 public List<AttributeContext> attribute() { 7606 return getRuleContexts(AttributeContext.class); 7607 } 7608 public AttributeContext attribute(int i) { 7609 return getRuleContext(AttributeContext.class,i); 7610 } 7611 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7612 public TerminalNode NEWLINE(int i) { 7613 return getToken(JavadocParser.NEWLINE, i); 7614 } 7615 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7616 public TerminalNode LEADING_ASTERISK(int i) { 7617 return getToken(JavadocParser.LEADING_ASTERISK, i); 7618 } 7619 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7620 public TerminalNode WS(int i) { 7621 return getToken(JavadocParser.WS, i); 7622 } 7623 public HeadTagOpenContext(ParserRuleContext parent, int invokingState) { 7624 super(parent, invokingState); 7625 } 7626 @Override public int getRuleIndex() { return RULE_headTagOpen; } 7627 @Override 7628 public void enterRule(ParseTreeListener listener) { 7629 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagOpen(this); 7630 } 7631 @Override 7632 public void exitRule(ParseTreeListener listener) { 7633 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagOpen(this); 7634 } 7635 @Override 7636 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7637 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagOpen(this); 7638 else return visitor.visitChildren(this); 7639 } 7640 } 7641 7642 public final HeadTagOpenContext headTagOpen() throws RecognitionException { 7643 HeadTagOpenContext _localctx = new HeadTagOpenContext(_ctx, getState()); 7644 enterRule(_localctx, 66, RULE_headTagOpen); 7645 int _la; 7646 try { 7647 enterOuterAlt(_localctx, 1); 7648 { 7649 setState(927); 7650 match(OPEN); 7651 setState(928); 7652 match(HEAD_HTML_TAG_NAME); 7653 setState(935); 7654 _errHandler.sync(this); 7655 _la = _input.LA(1); 7656 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 7657 { 7658 setState(933); 7659 switch (_input.LA(1)) { 7660 case HTML_TAG_NAME: 7661 { 7662 setState(929); 7663 attribute(); 7664 } 7665 break; 7666 case NEWLINE: 7667 { 7668 setState(930); 7669 match(NEWLINE); 7670 } 7671 break; 7672 case LEADING_ASTERISK: 7673 { 7674 setState(931); 7675 match(LEADING_ASTERISK); 7676 } 7677 break; 7678 case WS: 7679 { 7680 setState(932); 7681 match(WS); 7682 } 7683 break; 7684 default: 7685 throw new NoViableAltException(this); 7686 } 7687 } 7688 setState(937); 7689 _errHandler.sync(this); 7690 _la = _input.LA(1); 7691 } 7692 setState(938); 7693 match(CLOSE); 7694 } 7695 } 7696 catch (RecognitionException re) { 7697 _localctx.exception = re; 7698 _errHandler.reportError(this, re); 7699 _errHandler.recover(this, re); 7700 } 7701 finally { 7702 exitRule(); 7703 } 7704 return _localctx; 7705 } 7706 7707 public static class HeadTagCloseContext extends ParserRuleContext { 7708 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7709 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7710 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7711 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7712 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7713 public TerminalNode NEWLINE(int i) { 7714 return getToken(JavadocParser.NEWLINE, i); 7715 } 7716 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7717 public TerminalNode LEADING_ASTERISK(int i) { 7718 return getToken(JavadocParser.LEADING_ASTERISK, i); 7719 } 7720 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7721 public TerminalNode WS(int i) { 7722 return getToken(JavadocParser.WS, i); 7723 } 7724 public HeadTagCloseContext(ParserRuleContext parent, int invokingState) { 7725 super(parent, invokingState); 7726 } 7727 @Override public int getRuleIndex() { return RULE_headTagClose; } 7728 @Override 7729 public void enterRule(ParseTreeListener listener) { 7730 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagClose(this); 7731 } 7732 @Override 7733 public void exitRule(ParseTreeListener listener) { 7734 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagClose(this); 7735 } 7736 @Override 7737 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7738 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagClose(this); 7739 else return visitor.visitChildren(this); 7740 } 7741 } 7742 7743 public final HeadTagCloseContext headTagClose() throws RecognitionException { 7744 HeadTagCloseContext _localctx = new HeadTagCloseContext(_ctx, getState()); 7745 enterRule(_localctx, 68, RULE_headTagClose); 7746 int _la; 7747 try { 7748 enterOuterAlt(_localctx, 1); 7749 { 7750 setState(940); 7751 match(OPEN); 7752 setState(941); 7753 match(SLASH); 7754 setState(942); 7755 match(HEAD_HTML_TAG_NAME); 7756 setState(946); 7757 _errHandler.sync(this); 7758 _la = _input.LA(1); 7759 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7760 { 7761 { 7762 setState(943); 7763 _la = _input.LA(1); 7764 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7765 _errHandler.recoverInline(this); 7766 } else { 7767 consume(); 7768 } 7769 } 7770 } 7771 setState(948); 7772 _errHandler.sync(this); 7773 _la = _input.LA(1); 7774 } 7775 setState(949); 7776 match(CLOSE); 7777 } 7778 } 7779 catch (RecognitionException re) { 7780 _localctx.exception = re; 7781 _errHandler.reportError(this, re); 7782 _errHandler.recover(this, re); 7783 } 7784 finally { 7785 exitRule(); 7786 } 7787 return _localctx; 7788 } 7789 7790 public static class HeadContext extends ParserRuleContext { 7791 public HeadTagOpenContext headTagOpen() { 7792 return getRuleContext(HeadTagOpenContext.class,0); 7793 } 7794 public HeadTagCloseContext headTagClose() { 7795 return getRuleContext(HeadTagCloseContext.class,0); 7796 } 7797 public List<HtmlTagContext> htmlTag() { 7798 return getRuleContexts(HtmlTagContext.class); 7799 } 7800 public HtmlTagContext htmlTag(int i) { 7801 return getRuleContext(HtmlTagContext.class,i); 7802 } 7803 public List<SingletonTagContext> singletonTag() { 7804 return getRuleContexts(SingletonTagContext.class); 7805 } 7806 public SingletonTagContext singletonTag(int i) { 7807 return getRuleContext(SingletonTagContext.class,i); 7808 } 7809 public List<ParagraphContext> paragraph() { 7810 return getRuleContexts(ParagraphContext.class); 7811 } 7812 public ParagraphContext paragraph(int i) { 7813 return getRuleContext(ParagraphContext.class,i); 7814 } 7815 public List<LiContext> li() { 7816 return getRuleContexts(LiContext.class); 7817 } 7818 public LiContext li(int i) { 7819 return getRuleContext(LiContext.class,i); 7820 } 7821 public List<TrContext> tr() { 7822 return getRuleContexts(TrContext.class); 7823 } 7824 public TrContext tr(int i) { 7825 return getRuleContext(TrContext.class,i); 7826 } 7827 public List<TdContext> td() { 7828 return getRuleContexts(TdContext.class); 7829 } 7830 public TdContext td(int i) { 7831 return getRuleContext(TdContext.class,i); 7832 } 7833 public List<ThContext> th() { 7834 return getRuleContexts(ThContext.class); 7835 } 7836 public ThContext th(int i) { 7837 return getRuleContext(ThContext.class,i); 7838 } 7839 public List<BodyContext> body() { 7840 return getRuleContexts(BodyContext.class); 7841 } 7842 public BodyContext body(int i) { 7843 return getRuleContext(BodyContext.class,i); 7844 } 7845 public List<ColgroupContext> colgroup() { 7846 return getRuleContexts(ColgroupContext.class); 7847 } 7848 public ColgroupContext colgroup(int i) { 7849 return getRuleContext(ColgroupContext.class,i); 7850 } 7851 public List<DdContext> dd() { 7852 return getRuleContexts(DdContext.class); 7853 } 7854 public DdContext dd(int i) { 7855 return getRuleContext(DdContext.class,i); 7856 } 7857 public List<DtContext> dt() { 7858 return getRuleContexts(DtContext.class); 7859 } 7860 public DtContext dt(int i) { 7861 return getRuleContext(DtContext.class,i); 7862 } 7863 public List<HtmlContext> html() { 7864 return getRuleContexts(HtmlContext.class); 7865 } 7866 public HtmlContext html(int i) { 7867 return getRuleContext(HtmlContext.class,i); 7868 } 7869 public List<OptionContext> option() { 7870 return getRuleContexts(OptionContext.class); 7871 } 7872 public OptionContext option(int i) { 7873 return getRuleContext(OptionContext.class,i); 7874 } 7875 public List<TbodyContext> tbody() { 7876 return getRuleContexts(TbodyContext.class); 7877 } 7878 public TbodyContext tbody(int i) { 7879 return getRuleContext(TbodyContext.class,i); 7880 } 7881 public List<TheadContext> thead() { 7882 return getRuleContexts(TheadContext.class); 7883 } 7884 public TheadContext thead(int i) { 7885 return getRuleContext(TheadContext.class,i); 7886 } 7887 public List<TfootContext> tfoot() { 7888 return getRuleContexts(TfootContext.class); 7889 } 7890 public TfootContext tfoot(int i) { 7891 return getRuleContext(TfootContext.class,i); 7892 } 7893 public List<PTagOpenContext> pTagOpen() { 7894 return getRuleContexts(PTagOpenContext.class); 7895 } 7896 public PTagOpenContext pTagOpen(int i) { 7897 return getRuleContext(PTagOpenContext.class,i); 7898 } 7899 public List<LiTagOpenContext> liTagOpen() { 7900 return getRuleContexts(LiTagOpenContext.class); 7901 } 7902 public LiTagOpenContext liTagOpen(int i) { 7903 return getRuleContext(LiTagOpenContext.class,i); 7904 } 7905 public List<TrTagOpenContext> trTagOpen() { 7906 return getRuleContexts(TrTagOpenContext.class); 7907 } 7908 public TrTagOpenContext trTagOpen(int i) { 7909 return getRuleContext(TrTagOpenContext.class,i); 7910 } 7911 public List<TdTagOpenContext> tdTagOpen() { 7912 return getRuleContexts(TdTagOpenContext.class); 7913 } 7914 public TdTagOpenContext tdTagOpen(int i) { 7915 return getRuleContext(TdTagOpenContext.class,i); 7916 } 7917 public List<ThTagOpenContext> thTagOpen() { 7918 return getRuleContexts(ThTagOpenContext.class); 7919 } 7920 public ThTagOpenContext thTagOpen(int i) { 7921 return getRuleContext(ThTagOpenContext.class,i); 7922 } 7923 public List<BodyTagOpenContext> bodyTagOpen() { 7924 return getRuleContexts(BodyTagOpenContext.class); 7925 } 7926 public BodyTagOpenContext bodyTagOpen(int i) { 7927 return getRuleContext(BodyTagOpenContext.class,i); 7928 } 7929 public List<ColgroupTagOpenContext> colgroupTagOpen() { 7930 return getRuleContexts(ColgroupTagOpenContext.class); 7931 } 7932 public ColgroupTagOpenContext colgroupTagOpen(int i) { 7933 return getRuleContext(ColgroupTagOpenContext.class,i); 7934 } 7935 public List<DdTagOpenContext> ddTagOpen() { 7936 return getRuleContexts(DdTagOpenContext.class); 7937 } 7938 public DdTagOpenContext ddTagOpen(int i) { 7939 return getRuleContext(DdTagOpenContext.class,i); 7940 } 7941 public List<DtTagOpenContext> dtTagOpen() { 7942 return getRuleContexts(DtTagOpenContext.class); 7943 } 7944 public DtTagOpenContext dtTagOpen(int i) { 7945 return getRuleContext(DtTagOpenContext.class,i); 7946 } 7947 public List<HtmlTagOpenContext> htmlTagOpen() { 7948 return getRuleContexts(HtmlTagOpenContext.class); 7949 } 7950 public HtmlTagOpenContext htmlTagOpen(int i) { 7951 return getRuleContext(HtmlTagOpenContext.class,i); 7952 } 7953 public List<OptionTagOpenContext> optionTagOpen() { 7954 return getRuleContexts(OptionTagOpenContext.class); 7955 } 7956 public OptionTagOpenContext optionTagOpen(int i) { 7957 return getRuleContext(OptionTagOpenContext.class,i); 7958 } 7959 public List<TbodyTagOpenContext> tbodyTagOpen() { 7960 return getRuleContexts(TbodyTagOpenContext.class); 7961 } 7962 public TbodyTagOpenContext tbodyTagOpen(int i) { 7963 return getRuleContext(TbodyTagOpenContext.class,i); 7964 } 7965 public List<TheadTagOpenContext> theadTagOpen() { 7966 return getRuleContexts(TheadTagOpenContext.class); 7967 } 7968 public TheadTagOpenContext theadTagOpen(int i) { 7969 return getRuleContext(TheadTagOpenContext.class,i); 7970 } 7971 public List<TfootTagOpenContext> tfootTagOpen() { 7972 return getRuleContexts(TfootTagOpenContext.class); 7973 } 7974 public TfootTagOpenContext tfootTagOpen(int i) { 7975 return getRuleContext(TfootTagOpenContext.class,i); 7976 } 7977 public List<HtmlCommentContext> htmlComment() { 7978 return getRuleContexts(HtmlCommentContext.class); 7979 } 7980 public HtmlCommentContext htmlComment(int i) { 7981 return getRuleContext(HtmlCommentContext.class,i); 7982 } 7983 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 7984 public TerminalNode CDATA(int i) { 7985 return getToken(JavadocParser.CDATA, i); 7986 } 7987 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7988 public TerminalNode NEWLINE(int i) { 7989 return getToken(JavadocParser.NEWLINE, i); 7990 } 7991 public List<TextContext> text() { 7992 return getRuleContexts(TextContext.class); 7993 } 7994 public TextContext text(int i) { 7995 return getRuleContext(TextContext.class,i); 7996 } 7997 public List<JavadocInlineTagContext> javadocInlineTag() { 7998 return getRuleContexts(JavadocInlineTagContext.class); 7999 } 8000 public JavadocInlineTagContext javadocInlineTag(int i) { 8001 return getRuleContext(JavadocInlineTagContext.class,i); 8002 } 8003 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8004 public TerminalNode LEADING_ASTERISK(int i) { 8005 return getToken(JavadocParser.LEADING_ASTERISK, i); 8006 } 8007 public HeadContext(ParserRuleContext parent, int invokingState) { 8008 super(parent, invokingState); 8009 } 8010 @Override public int getRuleIndex() { return RULE_head; } 8011 @Override 8012 public void enterRule(ParseTreeListener listener) { 8013 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHead(this); 8014 } 8015 @Override 8016 public void exitRule(ParseTreeListener listener) { 8017 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHead(this); 8018 } 8019 @Override 8020 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8021 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHead(this); 8022 else return visitor.visitChildren(this); 8023 } 8024 } 8025 8026 public final HeadContext head() throws RecognitionException { 8027 HeadContext _localctx = new HeadContext(_ctx, getState()); 8028 enterRule(_localctx, 70, RULE_head); 8029 try { 8030 int _alt; 8031 enterOuterAlt(_localctx, 1); 8032 { 8033 setState(951); 8034 headTagOpen(); 8035 setState(991); 8036 _errHandler.sync(this); 8037 _alt = getInterpreter().adaptivePredict(_input,66,_ctx); 8038 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8039 if ( _alt==1 ) { 8040 { 8041 setState(989); 8042 _errHandler.sync(this); 8043 switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) { 8044 case 1: 8045 { 8046 setState(952); 8047 htmlTag(); 8048 } 8049 break; 8050 case 2: 8051 { 8052 setState(953); 8053 singletonTag(); 8054 } 8055 break; 8056 case 3: 8057 { 8058 setState(954); 8059 paragraph(); 8060 } 8061 break; 8062 case 4: 8063 { 8064 setState(955); 8065 li(); 8066 } 8067 break; 8068 case 5: 8069 { 8070 setState(956); 8071 tr(); 8072 } 8073 break; 8074 case 6: 8075 { 8076 setState(957); 8077 td(); 8078 } 8079 break; 8080 case 7: 8081 { 8082 setState(958); 8083 th(); 8084 } 8085 break; 8086 case 8: 8087 { 8088 setState(959); 8089 body(); 8090 } 8091 break; 8092 case 9: 8093 { 8094 setState(960); 8095 colgroup(); 8096 } 8097 break; 8098 case 10: 8099 { 8100 setState(961); 8101 dd(); 8102 } 8103 break; 8104 case 11: 8105 { 8106 setState(962); 8107 dt(); 8108 } 8109 break; 8110 case 12: 8111 { 8112 setState(963); 8113 html(); 8114 } 8115 break; 8116 case 13: 8117 { 8118 setState(964); 8119 option(); 8120 } 8121 break; 8122 case 14: 8123 { 8124 setState(965); 8125 tbody(); 8126 } 8127 break; 8128 case 15: 8129 { 8130 setState(966); 8131 thead(); 8132 } 8133 break; 8134 case 16: 8135 { 8136 setState(967); 8137 tfoot(); 8138 } 8139 break; 8140 case 17: 8141 { 8142 setState(968); 8143 pTagOpen(); 8144 } 8145 break; 8146 case 18: 8147 { 8148 setState(969); 8149 liTagOpen(); 8150 } 8151 break; 8152 case 19: 8153 { 8154 setState(970); 8155 trTagOpen(); 8156 } 8157 break; 8158 case 20: 8159 { 8160 setState(971); 8161 tdTagOpen(); 8162 } 8163 break; 8164 case 21: 8165 { 8166 setState(972); 8167 thTagOpen(); 8168 } 8169 break; 8170 case 22: 8171 { 8172 setState(973); 8173 bodyTagOpen(); 8174 } 8175 break; 8176 case 23: 8177 { 8178 setState(974); 8179 colgroupTagOpen(); 8180 } 8181 break; 8182 case 24: 8183 { 8184 setState(975); 8185 ddTagOpen(); 8186 } 8187 break; 8188 case 25: 8189 { 8190 setState(976); 8191 dtTagOpen(); 8192 } 8193 break; 8194 case 26: 8195 { 8196 setState(977); 8197 htmlTagOpen(); 8198 } 8199 break; 8200 case 27: 8201 { 8202 setState(978); 8203 optionTagOpen(); 8204 } 8205 break; 8206 case 28: 8207 { 8208 setState(979); 8209 tbodyTagOpen(); 8210 } 8211 break; 8212 case 29: 8213 { 8214 setState(980); 8215 theadTagOpen(); 8216 } 8217 break; 8218 case 30: 8219 { 8220 setState(981); 8221 tfootTagOpen(); 8222 } 8223 break; 8224 case 31: 8225 { 8226 { 8227 setState(982); 8228 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8229 setState(983); 8230 match(LEADING_ASTERISK); 8231 } 8232 } 8233 break; 8234 case 32: 8235 { 8236 setState(984); 8237 htmlComment(); 8238 } 8239 break; 8240 case 33: 8241 { 8242 setState(985); 8243 match(CDATA); 8244 } 8245 break; 8246 case 34: 8247 { 8248 setState(986); 8249 match(NEWLINE); 8250 } 8251 break; 8252 case 35: 8253 { 8254 setState(987); 8255 text(); 8256 } 8257 break; 8258 case 36: 8259 { 8260 setState(988); 8261 javadocInlineTag(); 8262 } 8263 break; 8264 } 8265 } 8266 } 8267 setState(993); 8268 _errHandler.sync(this); 8269 _alt = getInterpreter().adaptivePredict(_input,66,_ctx); 8270 } 8271 setState(994); 8272 headTagClose(); 8273 } 8274 } 8275 catch (RecognitionException re) { 8276 _localctx.exception = re; 8277 _errHandler.reportError(this, re); 8278 _errHandler.recover(this, re); 8279 } 8280 finally { 8281 exitRule(); 8282 } 8283 return _localctx; 8284 } 8285 8286 public static class HtmlTagOpenContext extends ParserRuleContext { 8287 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8288 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 8289 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8290 public List<AttributeContext> attribute() { 8291 return getRuleContexts(AttributeContext.class); 8292 } 8293 public AttributeContext attribute(int i) { 8294 return getRuleContext(AttributeContext.class,i); 8295 } 8296 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8297 public TerminalNode NEWLINE(int i) { 8298 return getToken(JavadocParser.NEWLINE, i); 8299 } 8300 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8301 public TerminalNode LEADING_ASTERISK(int i) { 8302 return getToken(JavadocParser.LEADING_ASTERISK, i); 8303 } 8304 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8305 public TerminalNode WS(int i) { 8306 return getToken(JavadocParser.WS, i); 8307 } 8308 public HtmlTagOpenContext(ParserRuleContext parent, int invokingState) { 8309 super(parent, invokingState); 8310 } 8311 @Override public int getRuleIndex() { return RULE_htmlTagOpen; } 8312 @Override 8313 public void enterRule(ParseTreeListener listener) { 8314 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagOpen(this); 8315 } 8316 @Override 8317 public void exitRule(ParseTreeListener listener) { 8318 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagOpen(this); 8319 } 8320 @Override 8321 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8322 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagOpen(this); 8323 else return visitor.visitChildren(this); 8324 } 8325 } 8326 8327 public final HtmlTagOpenContext htmlTagOpen() throws RecognitionException { 8328 HtmlTagOpenContext _localctx = new HtmlTagOpenContext(_ctx, getState()); 8329 enterRule(_localctx, 72, RULE_htmlTagOpen); 8330 int _la; 8331 try { 8332 enterOuterAlt(_localctx, 1); 8333 { 8334 setState(996); 8335 match(OPEN); 8336 setState(997); 8337 match(HTML_HTML_TAG_NAME); 8338 setState(1004); 8339 _errHandler.sync(this); 8340 _la = _input.LA(1); 8341 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 8342 { 8343 setState(1002); 8344 switch (_input.LA(1)) { 8345 case HTML_TAG_NAME: 8346 { 8347 setState(998); 8348 attribute(); 8349 } 8350 break; 8351 case NEWLINE: 8352 { 8353 setState(999); 8354 match(NEWLINE); 8355 } 8356 break; 8357 case LEADING_ASTERISK: 8358 { 8359 setState(1000); 8360 match(LEADING_ASTERISK); 8361 } 8362 break; 8363 case WS: 8364 { 8365 setState(1001); 8366 match(WS); 8367 } 8368 break; 8369 default: 8370 throw new NoViableAltException(this); 8371 } 8372 } 8373 setState(1006); 8374 _errHandler.sync(this); 8375 _la = _input.LA(1); 8376 } 8377 setState(1007); 8378 match(CLOSE); 8379 } 8380 } 8381 catch (RecognitionException re) { 8382 _localctx.exception = re; 8383 _errHandler.reportError(this, re); 8384 _errHandler.recover(this, re); 8385 } 8386 finally { 8387 exitRule(); 8388 } 8389 return _localctx; 8390 } 8391 8392 public static class HtmlTagCloseContext extends ParserRuleContext { 8393 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8394 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 8395 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 8396 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8397 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8398 public TerminalNode NEWLINE(int i) { 8399 return getToken(JavadocParser.NEWLINE, i); 8400 } 8401 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8402 public TerminalNode LEADING_ASTERISK(int i) { 8403 return getToken(JavadocParser.LEADING_ASTERISK, i); 8404 } 8405 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8406 public TerminalNode WS(int i) { 8407 return getToken(JavadocParser.WS, i); 8408 } 8409 public HtmlTagCloseContext(ParserRuleContext parent, int invokingState) { 8410 super(parent, invokingState); 8411 } 8412 @Override public int getRuleIndex() { return RULE_htmlTagClose; } 8413 @Override 8414 public void enterRule(ParseTreeListener listener) { 8415 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagClose(this); 8416 } 8417 @Override 8418 public void exitRule(ParseTreeListener listener) { 8419 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagClose(this); 8420 } 8421 @Override 8422 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8423 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagClose(this); 8424 else return visitor.visitChildren(this); 8425 } 8426 } 8427 8428 public final HtmlTagCloseContext htmlTagClose() throws RecognitionException { 8429 HtmlTagCloseContext _localctx = new HtmlTagCloseContext(_ctx, getState()); 8430 enterRule(_localctx, 74, RULE_htmlTagClose); 8431 int _la; 8432 try { 8433 enterOuterAlt(_localctx, 1); 8434 { 8435 setState(1009); 8436 match(OPEN); 8437 setState(1010); 8438 match(SLASH); 8439 setState(1011); 8440 match(HTML_HTML_TAG_NAME); 8441 setState(1015); 8442 _errHandler.sync(this); 8443 _la = _input.LA(1); 8444 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 8445 { 8446 { 8447 setState(1012); 8448 _la = _input.LA(1); 8449 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 8450 _errHandler.recoverInline(this); 8451 } else { 8452 consume(); 8453 } 8454 } 8455 } 8456 setState(1017); 8457 _errHandler.sync(this); 8458 _la = _input.LA(1); 8459 } 8460 setState(1018); 8461 match(CLOSE); 8462 } 8463 } 8464 catch (RecognitionException re) { 8465 _localctx.exception = re; 8466 _errHandler.reportError(this, re); 8467 _errHandler.recover(this, re); 8468 } 8469 finally { 8470 exitRule(); 8471 } 8472 return _localctx; 8473 } 8474 8475 public static class HtmlContext extends ParserRuleContext { 8476 public HtmlTagOpenContext htmlTagOpen() { 8477 return getRuleContext(HtmlTagOpenContext.class,0); 8478 } 8479 public HtmlTagCloseContext htmlTagClose() { 8480 return getRuleContext(HtmlTagCloseContext.class,0); 8481 } 8482 public List<HtmlTagContext> htmlTag() { 8483 return getRuleContexts(HtmlTagContext.class); 8484 } 8485 public HtmlTagContext htmlTag(int i) { 8486 return getRuleContext(HtmlTagContext.class,i); 8487 } 8488 public List<SingletonTagContext> singletonTag() { 8489 return getRuleContexts(SingletonTagContext.class); 8490 } 8491 public SingletonTagContext singletonTag(int i) { 8492 return getRuleContext(SingletonTagContext.class,i); 8493 } 8494 public List<ParagraphContext> paragraph() { 8495 return getRuleContexts(ParagraphContext.class); 8496 } 8497 public ParagraphContext paragraph(int i) { 8498 return getRuleContext(ParagraphContext.class,i); 8499 } 8500 public List<LiContext> li() { 8501 return getRuleContexts(LiContext.class); 8502 } 8503 public LiContext li(int i) { 8504 return getRuleContext(LiContext.class,i); 8505 } 8506 public List<TrContext> tr() { 8507 return getRuleContexts(TrContext.class); 8508 } 8509 public TrContext tr(int i) { 8510 return getRuleContext(TrContext.class,i); 8511 } 8512 public List<TdContext> td() { 8513 return getRuleContexts(TdContext.class); 8514 } 8515 public TdContext td(int i) { 8516 return getRuleContext(TdContext.class,i); 8517 } 8518 public List<ThContext> th() { 8519 return getRuleContexts(ThContext.class); 8520 } 8521 public ThContext th(int i) { 8522 return getRuleContext(ThContext.class,i); 8523 } 8524 public List<BodyContext> body() { 8525 return getRuleContexts(BodyContext.class); 8526 } 8527 public BodyContext body(int i) { 8528 return getRuleContext(BodyContext.class,i); 8529 } 8530 public List<ColgroupContext> colgroup() { 8531 return getRuleContexts(ColgroupContext.class); 8532 } 8533 public ColgroupContext colgroup(int i) { 8534 return getRuleContext(ColgroupContext.class,i); 8535 } 8536 public List<DdContext> dd() { 8537 return getRuleContexts(DdContext.class); 8538 } 8539 public DdContext dd(int i) { 8540 return getRuleContext(DdContext.class,i); 8541 } 8542 public List<DtContext> dt() { 8543 return getRuleContexts(DtContext.class); 8544 } 8545 public DtContext dt(int i) { 8546 return getRuleContext(DtContext.class,i); 8547 } 8548 public List<HeadContext> head() { 8549 return getRuleContexts(HeadContext.class); 8550 } 8551 public HeadContext head(int i) { 8552 return getRuleContext(HeadContext.class,i); 8553 } 8554 public List<OptionContext> option() { 8555 return getRuleContexts(OptionContext.class); 8556 } 8557 public OptionContext option(int i) { 8558 return getRuleContext(OptionContext.class,i); 8559 } 8560 public List<TbodyContext> tbody() { 8561 return getRuleContexts(TbodyContext.class); 8562 } 8563 public TbodyContext tbody(int i) { 8564 return getRuleContext(TbodyContext.class,i); 8565 } 8566 public List<TheadContext> thead() { 8567 return getRuleContexts(TheadContext.class); 8568 } 8569 public TheadContext thead(int i) { 8570 return getRuleContext(TheadContext.class,i); 8571 } 8572 public List<TfootContext> tfoot() { 8573 return getRuleContexts(TfootContext.class); 8574 } 8575 public TfootContext tfoot(int i) { 8576 return getRuleContext(TfootContext.class,i); 8577 } 8578 public List<PTagOpenContext> pTagOpen() { 8579 return getRuleContexts(PTagOpenContext.class); 8580 } 8581 public PTagOpenContext pTagOpen(int i) { 8582 return getRuleContext(PTagOpenContext.class,i); 8583 } 8584 public List<LiTagOpenContext> liTagOpen() { 8585 return getRuleContexts(LiTagOpenContext.class); 8586 } 8587 public LiTagOpenContext liTagOpen(int i) { 8588 return getRuleContext(LiTagOpenContext.class,i); 8589 } 8590 public List<TrTagOpenContext> trTagOpen() { 8591 return getRuleContexts(TrTagOpenContext.class); 8592 } 8593 public TrTagOpenContext trTagOpen(int i) { 8594 return getRuleContext(TrTagOpenContext.class,i); 8595 } 8596 public List<TdTagOpenContext> tdTagOpen() { 8597 return getRuleContexts(TdTagOpenContext.class); 8598 } 8599 public TdTagOpenContext tdTagOpen(int i) { 8600 return getRuleContext(TdTagOpenContext.class,i); 8601 } 8602 public List<ThTagOpenContext> thTagOpen() { 8603 return getRuleContexts(ThTagOpenContext.class); 8604 } 8605 public ThTagOpenContext thTagOpen(int i) { 8606 return getRuleContext(ThTagOpenContext.class,i); 8607 } 8608 public List<BodyTagOpenContext> bodyTagOpen() { 8609 return getRuleContexts(BodyTagOpenContext.class); 8610 } 8611 public BodyTagOpenContext bodyTagOpen(int i) { 8612 return getRuleContext(BodyTagOpenContext.class,i); 8613 } 8614 public List<ColgroupTagOpenContext> colgroupTagOpen() { 8615 return getRuleContexts(ColgroupTagOpenContext.class); 8616 } 8617 public ColgroupTagOpenContext colgroupTagOpen(int i) { 8618 return getRuleContext(ColgroupTagOpenContext.class,i); 8619 } 8620 public List<DdTagOpenContext> ddTagOpen() { 8621 return getRuleContexts(DdTagOpenContext.class); 8622 } 8623 public DdTagOpenContext ddTagOpen(int i) { 8624 return getRuleContext(DdTagOpenContext.class,i); 8625 } 8626 public List<DtTagOpenContext> dtTagOpen() { 8627 return getRuleContexts(DtTagOpenContext.class); 8628 } 8629 public DtTagOpenContext dtTagOpen(int i) { 8630 return getRuleContext(DtTagOpenContext.class,i); 8631 } 8632 public List<HeadTagOpenContext> headTagOpen() { 8633 return getRuleContexts(HeadTagOpenContext.class); 8634 } 8635 public HeadTagOpenContext headTagOpen(int i) { 8636 return getRuleContext(HeadTagOpenContext.class,i); 8637 } 8638 public List<OptionTagOpenContext> optionTagOpen() { 8639 return getRuleContexts(OptionTagOpenContext.class); 8640 } 8641 public OptionTagOpenContext optionTagOpen(int i) { 8642 return getRuleContext(OptionTagOpenContext.class,i); 8643 } 8644 public List<TbodyTagOpenContext> tbodyTagOpen() { 8645 return getRuleContexts(TbodyTagOpenContext.class); 8646 } 8647 public TbodyTagOpenContext tbodyTagOpen(int i) { 8648 return getRuleContext(TbodyTagOpenContext.class,i); 8649 } 8650 public List<TheadTagOpenContext> theadTagOpen() { 8651 return getRuleContexts(TheadTagOpenContext.class); 8652 } 8653 public TheadTagOpenContext theadTagOpen(int i) { 8654 return getRuleContext(TheadTagOpenContext.class,i); 8655 } 8656 public List<TfootTagOpenContext> tfootTagOpen() { 8657 return getRuleContexts(TfootTagOpenContext.class); 8658 } 8659 public TfootTagOpenContext tfootTagOpen(int i) { 8660 return getRuleContext(TfootTagOpenContext.class,i); 8661 } 8662 public List<HtmlCommentContext> htmlComment() { 8663 return getRuleContexts(HtmlCommentContext.class); 8664 } 8665 public HtmlCommentContext htmlComment(int i) { 8666 return getRuleContext(HtmlCommentContext.class,i); 8667 } 8668 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8669 public TerminalNode CDATA(int i) { 8670 return getToken(JavadocParser.CDATA, i); 8671 } 8672 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8673 public TerminalNode NEWLINE(int i) { 8674 return getToken(JavadocParser.NEWLINE, i); 8675 } 8676 public List<TextContext> text() { 8677 return getRuleContexts(TextContext.class); 8678 } 8679 public TextContext text(int i) { 8680 return getRuleContext(TextContext.class,i); 8681 } 8682 public List<JavadocInlineTagContext> javadocInlineTag() { 8683 return getRuleContexts(JavadocInlineTagContext.class); 8684 } 8685 public JavadocInlineTagContext javadocInlineTag(int i) { 8686 return getRuleContext(JavadocInlineTagContext.class,i); 8687 } 8688 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8689 public TerminalNode LEADING_ASTERISK(int i) { 8690 return getToken(JavadocParser.LEADING_ASTERISK, i); 8691 } 8692 public HtmlContext(ParserRuleContext parent, int invokingState) { 8693 super(parent, invokingState); 8694 } 8695 @Override public int getRuleIndex() { return RULE_html; } 8696 @Override 8697 public void enterRule(ParseTreeListener listener) { 8698 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtml(this); 8699 } 8700 @Override 8701 public void exitRule(ParseTreeListener listener) { 8702 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtml(this); 8703 } 8704 @Override 8705 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8706 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtml(this); 8707 else return visitor.visitChildren(this); 8708 } 8709 } 8710 8711 public final HtmlContext html() throws RecognitionException { 8712 HtmlContext _localctx = new HtmlContext(_ctx, getState()); 8713 enterRule(_localctx, 76, RULE_html); 8714 try { 8715 int _alt; 8716 enterOuterAlt(_localctx, 1); 8717 { 8718 setState(1020); 8719 htmlTagOpen(); 8720 setState(1060); 8721 _errHandler.sync(this); 8722 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 8723 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8724 if ( _alt==1 ) { 8725 { 8726 setState(1058); 8727 _errHandler.sync(this); 8728 switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { 8729 case 1: 8730 { 8731 setState(1021); 8732 htmlTag(); 8733 } 8734 break; 8735 case 2: 8736 { 8737 setState(1022); 8738 singletonTag(); 8739 } 8740 break; 8741 case 3: 8742 { 8743 setState(1023); 8744 paragraph(); 8745 } 8746 break; 8747 case 4: 8748 { 8749 setState(1024); 8750 li(); 8751 } 8752 break; 8753 case 5: 8754 { 8755 setState(1025); 8756 tr(); 8757 } 8758 break; 8759 case 6: 8760 { 8761 setState(1026); 8762 td(); 8763 } 8764 break; 8765 case 7: 8766 { 8767 setState(1027); 8768 th(); 8769 } 8770 break; 8771 case 8: 8772 { 8773 setState(1028); 8774 body(); 8775 } 8776 break; 8777 case 9: 8778 { 8779 setState(1029); 8780 colgroup(); 8781 } 8782 break; 8783 case 10: 8784 { 8785 setState(1030); 8786 dd(); 8787 } 8788 break; 8789 case 11: 8790 { 8791 setState(1031); 8792 dt(); 8793 } 8794 break; 8795 case 12: 8796 { 8797 setState(1032); 8798 head(); 8799 } 8800 break; 8801 case 13: 8802 { 8803 setState(1033); 8804 option(); 8805 } 8806 break; 8807 case 14: 8808 { 8809 setState(1034); 8810 tbody(); 8811 } 8812 break; 8813 case 15: 8814 { 8815 setState(1035); 8816 thead(); 8817 } 8818 break; 8819 case 16: 8820 { 8821 setState(1036); 8822 tfoot(); 8823 } 8824 break; 8825 case 17: 8826 { 8827 setState(1037); 8828 pTagOpen(); 8829 } 8830 break; 8831 case 18: 8832 { 8833 setState(1038); 8834 liTagOpen(); 8835 } 8836 break; 8837 case 19: 8838 { 8839 setState(1039); 8840 trTagOpen(); 8841 } 8842 break; 8843 case 20: 8844 { 8845 setState(1040); 8846 tdTagOpen(); 8847 } 8848 break; 8849 case 21: 8850 { 8851 setState(1041); 8852 thTagOpen(); 8853 } 8854 break; 8855 case 22: 8856 { 8857 setState(1042); 8858 bodyTagOpen(); 8859 } 8860 break; 8861 case 23: 8862 { 8863 setState(1043); 8864 colgroupTagOpen(); 8865 } 8866 break; 8867 case 24: 8868 { 8869 setState(1044); 8870 ddTagOpen(); 8871 } 8872 break; 8873 case 25: 8874 { 8875 setState(1045); 8876 dtTagOpen(); 8877 } 8878 break; 8879 case 26: 8880 { 8881 setState(1046); 8882 headTagOpen(); 8883 } 8884 break; 8885 case 27: 8886 { 8887 setState(1047); 8888 optionTagOpen(); 8889 } 8890 break; 8891 case 28: 8892 { 8893 setState(1048); 8894 tbodyTagOpen(); 8895 } 8896 break; 8897 case 29: 8898 { 8899 setState(1049); 8900 theadTagOpen(); 8901 } 8902 break; 8903 case 30: 8904 { 8905 setState(1050); 8906 tfootTagOpen(); 8907 } 8908 break; 8909 case 31: 8910 { 8911 { 8912 setState(1051); 8913 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8914 setState(1052); 8915 match(LEADING_ASTERISK); 8916 } 8917 } 8918 break; 8919 case 32: 8920 { 8921 setState(1053); 8922 htmlComment(); 8923 } 8924 break; 8925 case 33: 8926 { 8927 setState(1054); 8928 match(CDATA); 8929 } 8930 break; 8931 case 34: 8932 { 8933 setState(1055); 8934 match(NEWLINE); 8935 } 8936 break; 8937 case 35: 8938 { 8939 setState(1056); 8940 text(); 8941 } 8942 break; 8943 case 36: 8944 { 8945 setState(1057); 8946 javadocInlineTag(); 8947 } 8948 break; 8949 } 8950 } 8951 } 8952 setState(1062); 8953 _errHandler.sync(this); 8954 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 8955 } 8956 setState(1063); 8957 htmlTagClose(); 8958 } 8959 } 8960 catch (RecognitionException re) { 8961 _localctx.exception = re; 8962 _errHandler.reportError(this, re); 8963 _errHandler.recover(this, re); 8964 } 8965 finally { 8966 exitRule(); 8967 } 8968 return _localctx; 8969 } 8970 8971 public static class OptionTagOpenContext extends ParserRuleContext { 8972 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8973 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 8974 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8975 public List<AttributeContext> attribute() { 8976 return getRuleContexts(AttributeContext.class); 8977 } 8978 public AttributeContext attribute(int i) { 8979 return getRuleContext(AttributeContext.class,i); 8980 } 8981 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8982 public TerminalNode NEWLINE(int i) { 8983 return getToken(JavadocParser.NEWLINE, i); 8984 } 8985 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8986 public TerminalNode LEADING_ASTERISK(int i) { 8987 return getToken(JavadocParser.LEADING_ASTERISK, i); 8988 } 8989 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8990 public TerminalNode WS(int i) { 8991 return getToken(JavadocParser.WS, i); 8992 } 8993 public OptionTagOpenContext(ParserRuleContext parent, int invokingState) { 8994 super(parent, invokingState); 8995 } 8996 @Override public int getRuleIndex() { return RULE_optionTagOpen; } 8997 @Override 8998 public void enterRule(ParseTreeListener listener) { 8999 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagOpen(this); 9000 } 9001 @Override 9002 public void exitRule(ParseTreeListener listener) { 9003 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagOpen(this); 9004 } 9005 @Override 9006 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9007 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagOpen(this); 9008 else return visitor.visitChildren(this); 9009 } 9010 } 9011 9012 public final OptionTagOpenContext optionTagOpen() throws RecognitionException { 9013 OptionTagOpenContext _localctx = new OptionTagOpenContext(_ctx, getState()); 9014 enterRule(_localctx, 78, RULE_optionTagOpen); 9015 int _la; 9016 try { 9017 enterOuterAlt(_localctx, 1); 9018 { 9019 setState(1065); 9020 match(OPEN); 9021 setState(1066); 9022 match(OPTION_HTML_TAG_NAME); 9023 setState(1073); 9024 _errHandler.sync(this); 9025 _la = _input.LA(1); 9026 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9027 { 9028 setState(1071); 9029 switch (_input.LA(1)) { 9030 case HTML_TAG_NAME: 9031 { 9032 setState(1067); 9033 attribute(); 9034 } 9035 break; 9036 case NEWLINE: 9037 { 9038 setState(1068); 9039 match(NEWLINE); 9040 } 9041 break; 9042 case LEADING_ASTERISK: 9043 { 9044 setState(1069); 9045 match(LEADING_ASTERISK); 9046 } 9047 break; 9048 case WS: 9049 { 9050 setState(1070); 9051 match(WS); 9052 } 9053 break; 9054 default: 9055 throw new NoViableAltException(this); 9056 } 9057 } 9058 setState(1075); 9059 _errHandler.sync(this); 9060 _la = _input.LA(1); 9061 } 9062 setState(1076); 9063 match(CLOSE); 9064 } 9065 } 9066 catch (RecognitionException re) { 9067 _localctx.exception = re; 9068 _errHandler.reportError(this, re); 9069 _errHandler.recover(this, re); 9070 } 9071 finally { 9072 exitRule(); 9073 } 9074 return _localctx; 9075 } 9076 9077 public static class OptionTagCloseContext extends ParserRuleContext { 9078 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9079 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9080 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 9081 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9082 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9083 public TerminalNode NEWLINE(int i) { 9084 return getToken(JavadocParser.NEWLINE, i); 9085 } 9086 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9087 public TerminalNode LEADING_ASTERISK(int i) { 9088 return getToken(JavadocParser.LEADING_ASTERISK, i); 9089 } 9090 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9091 public TerminalNode WS(int i) { 9092 return getToken(JavadocParser.WS, i); 9093 } 9094 public OptionTagCloseContext(ParserRuleContext parent, int invokingState) { 9095 super(parent, invokingState); 9096 } 9097 @Override public int getRuleIndex() { return RULE_optionTagClose; } 9098 @Override 9099 public void enterRule(ParseTreeListener listener) { 9100 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagClose(this); 9101 } 9102 @Override 9103 public void exitRule(ParseTreeListener listener) { 9104 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagClose(this); 9105 } 9106 @Override 9107 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9108 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagClose(this); 9109 else return visitor.visitChildren(this); 9110 } 9111 } 9112 9113 public final OptionTagCloseContext optionTagClose() throws RecognitionException { 9114 OptionTagCloseContext _localctx = new OptionTagCloseContext(_ctx, getState()); 9115 enterRule(_localctx, 80, RULE_optionTagClose); 9116 int _la; 9117 try { 9118 enterOuterAlt(_localctx, 1); 9119 { 9120 setState(1078); 9121 match(OPEN); 9122 setState(1079); 9123 match(SLASH); 9124 setState(1080); 9125 match(OPTION_HTML_TAG_NAME); 9126 setState(1084); 9127 _errHandler.sync(this); 9128 _la = _input.LA(1); 9129 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9130 { 9131 { 9132 setState(1081); 9133 _la = _input.LA(1); 9134 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9135 _errHandler.recoverInline(this); 9136 } else { 9137 consume(); 9138 } 9139 } 9140 } 9141 setState(1086); 9142 _errHandler.sync(this); 9143 _la = _input.LA(1); 9144 } 9145 setState(1087); 9146 match(CLOSE); 9147 } 9148 } 9149 catch (RecognitionException re) { 9150 _localctx.exception = re; 9151 _errHandler.reportError(this, re); 9152 _errHandler.recover(this, re); 9153 } 9154 finally { 9155 exitRule(); 9156 } 9157 return _localctx; 9158 } 9159 9160 public static class OptionContext extends ParserRuleContext { 9161 public OptionTagOpenContext optionTagOpen() { 9162 return getRuleContext(OptionTagOpenContext.class,0); 9163 } 9164 public OptionTagCloseContext optionTagClose() { 9165 return getRuleContext(OptionTagCloseContext.class,0); 9166 } 9167 public List<HtmlTagContext> htmlTag() { 9168 return getRuleContexts(HtmlTagContext.class); 9169 } 9170 public HtmlTagContext htmlTag(int i) { 9171 return getRuleContext(HtmlTagContext.class,i); 9172 } 9173 public List<SingletonTagContext> singletonTag() { 9174 return getRuleContexts(SingletonTagContext.class); 9175 } 9176 public SingletonTagContext singletonTag(int i) { 9177 return getRuleContext(SingletonTagContext.class,i); 9178 } 9179 public List<ParagraphContext> paragraph() { 9180 return getRuleContexts(ParagraphContext.class); 9181 } 9182 public ParagraphContext paragraph(int i) { 9183 return getRuleContext(ParagraphContext.class,i); 9184 } 9185 public List<LiContext> li() { 9186 return getRuleContexts(LiContext.class); 9187 } 9188 public LiContext li(int i) { 9189 return getRuleContext(LiContext.class,i); 9190 } 9191 public List<TrContext> tr() { 9192 return getRuleContexts(TrContext.class); 9193 } 9194 public TrContext tr(int i) { 9195 return getRuleContext(TrContext.class,i); 9196 } 9197 public List<TdContext> td() { 9198 return getRuleContexts(TdContext.class); 9199 } 9200 public TdContext td(int i) { 9201 return getRuleContext(TdContext.class,i); 9202 } 9203 public List<ThContext> th() { 9204 return getRuleContexts(ThContext.class); 9205 } 9206 public ThContext th(int i) { 9207 return getRuleContext(ThContext.class,i); 9208 } 9209 public List<BodyContext> body() { 9210 return getRuleContexts(BodyContext.class); 9211 } 9212 public BodyContext body(int i) { 9213 return getRuleContext(BodyContext.class,i); 9214 } 9215 public List<ColgroupContext> colgroup() { 9216 return getRuleContexts(ColgroupContext.class); 9217 } 9218 public ColgroupContext colgroup(int i) { 9219 return getRuleContext(ColgroupContext.class,i); 9220 } 9221 public List<DdContext> dd() { 9222 return getRuleContexts(DdContext.class); 9223 } 9224 public DdContext dd(int i) { 9225 return getRuleContext(DdContext.class,i); 9226 } 9227 public List<DtContext> dt() { 9228 return getRuleContexts(DtContext.class); 9229 } 9230 public DtContext dt(int i) { 9231 return getRuleContext(DtContext.class,i); 9232 } 9233 public List<HeadContext> head() { 9234 return getRuleContexts(HeadContext.class); 9235 } 9236 public HeadContext head(int i) { 9237 return getRuleContext(HeadContext.class,i); 9238 } 9239 public List<HtmlContext> html() { 9240 return getRuleContexts(HtmlContext.class); 9241 } 9242 public HtmlContext html(int i) { 9243 return getRuleContext(HtmlContext.class,i); 9244 } 9245 public List<TbodyContext> tbody() { 9246 return getRuleContexts(TbodyContext.class); 9247 } 9248 public TbodyContext tbody(int i) { 9249 return getRuleContext(TbodyContext.class,i); 9250 } 9251 public List<TheadContext> thead() { 9252 return getRuleContexts(TheadContext.class); 9253 } 9254 public TheadContext thead(int i) { 9255 return getRuleContext(TheadContext.class,i); 9256 } 9257 public List<TfootContext> tfoot() { 9258 return getRuleContexts(TfootContext.class); 9259 } 9260 public TfootContext tfoot(int i) { 9261 return getRuleContext(TfootContext.class,i); 9262 } 9263 public List<PTagOpenContext> pTagOpen() { 9264 return getRuleContexts(PTagOpenContext.class); 9265 } 9266 public PTagOpenContext pTagOpen(int i) { 9267 return getRuleContext(PTagOpenContext.class,i); 9268 } 9269 public List<LiTagOpenContext> liTagOpen() { 9270 return getRuleContexts(LiTagOpenContext.class); 9271 } 9272 public LiTagOpenContext liTagOpen(int i) { 9273 return getRuleContext(LiTagOpenContext.class,i); 9274 } 9275 public List<TrTagOpenContext> trTagOpen() { 9276 return getRuleContexts(TrTagOpenContext.class); 9277 } 9278 public TrTagOpenContext trTagOpen(int i) { 9279 return getRuleContext(TrTagOpenContext.class,i); 9280 } 9281 public List<TdTagOpenContext> tdTagOpen() { 9282 return getRuleContexts(TdTagOpenContext.class); 9283 } 9284 public TdTagOpenContext tdTagOpen(int i) { 9285 return getRuleContext(TdTagOpenContext.class,i); 9286 } 9287 public List<ThTagOpenContext> thTagOpen() { 9288 return getRuleContexts(ThTagOpenContext.class); 9289 } 9290 public ThTagOpenContext thTagOpen(int i) { 9291 return getRuleContext(ThTagOpenContext.class,i); 9292 } 9293 public List<BodyTagOpenContext> bodyTagOpen() { 9294 return getRuleContexts(BodyTagOpenContext.class); 9295 } 9296 public BodyTagOpenContext bodyTagOpen(int i) { 9297 return getRuleContext(BodyTagOpenContext.class,i); 9298 } 9299 public List<ColgroupTagOpenContext> colgroupTagOpen() { 9300 return getRuleContexts(ColgroupTagOpenContext.class); 9301 } 9302 public ColgroupTagOpenContext colgroupTagOpen(int i) { 9303 return getRuleContext(ColgroupTagOpenContext.class,i); 9304 } 9305 public List<DdTagOpenContext> ddTagOpen() { 9306 return getRuleContexts(DdTagOpenContext.class); 9307 } 9308 public DdTagOpenContext ddTagOpen(int i) { 9309 return getRuleContext(DdTagOpenContext.class,i); 9310 } 9311 public List<DtTagOpenContext> dtTagOpen() { 9312 return getRuleContexts(DtTagOpenContext.class); 9313 } 9314 public DtTagOpenContext dtTagOpen(int i) { 9315 return getRuleContext(DtTagOpenContext.class,i); 9316 } 9317 public List<HeadTagOpenContext> headTagOpen() { 9318 return getRuleContexts(HeadTagOpenContext.class); 9319 } 9320 public HeadTagOpenContext headTagOpen(int i) { 9321 return getRuleContext(HeadTagOpenContext.class,i); 9322 } 9323 public List<HtmlTagOpenContext> htmlTagOpen() { 9324 return getRuleContexts(HtmlTagOpenContext.class); 9325 } 9326 public HtmlTagOpenContext htmlTagOpen(int i) { 9327 return getRuleContext(HtmlTagOpenContext.class,i); 9328 } 9329 public List<TbodyTagOpenContext> tbodyTagOpen() { 9330 return getRuleContexts(TbodyTagOpenContext.class); 9331 } 9332 public TbodyTagOpenContext tbodyTagOpen(int i) { 9333 return getRuleContext(TbodyTagOpenContext.class,i); 9334 } 9335 public List<TheadTagOpenContext> theadTagOpen() { 9336 return getRuleContexts(TheadTagOpenContext.class); 9337 } 9338 public TheadTagOpenContext theadTagOpen(int i) { 9339 return getRuleContext(TheadTagOpenContext.class,i); 9340 } 9341 public List<TfootTagOpenContext> tfootTagOpen() { 9342 return getRuleContexts(TfootTagOpenContext.class); 9343 } 9344 public TfootTagOpenContext tfootTagOpen(int i) { 9345 return getRuleContext(TfootTagOpenContext.class,i); 9346 } 9347 public List<HtmlCommentContext> htmlComment() { 9348 return getRuleContexts(HtmlCommentContext.class); 9349 } 9350 public HtmlCommentContext htmlComment(int i) { 9351 return getRuleContext(HtmlCommentContext.class,i); 9352 } 9353 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 9354 public TerminalNode CDATA(int i) { 9355 return getToken(JavadocParser.CDATA, i); 9356 } 9357 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9358 public TerminalNode NEWLINE(int i) { 9359 return getToken(JavadocParser.NEWLINE, i); 9360 } 9361 public List<TextContext> text() { 9362 return getRuleContexts(TextContext.class); 9363 } 9364 public TextContext text(int i) { 9365 return getRuleContext(TextContext.class,i); 9366 } 9367 public List<JavadocInlineTagContext> javadocInlineTag() { 9368 return getRuleContexts(JavadocInlineTagContext.class); 9369 } 9370 public JavadocInlineTagContext javadocInlineTag(int i) { 9371 return getRuleContext(JavadocInlineTagContext.class,i); 9372 } 9373 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9374 public TerminalNode LEADING_ASTERISK(int i) { 9375 return getToken(JavadocParser.LEADING_ASTERISK, i); 9376 } 9377 public OptionContext(ParserRuleContext parent, int invokingState) { 9378 super(parent, invokingState); 9379 } 9380 @Override public int getRuleIndex() { return RULE_option; } 9381 @Override 9382 public void enterRule(ParseTreeListener listener) { 9383 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOption(this); 9384 } 9385 @Override 9386 public void exitRule(ParseTreeListener listener) { 9387 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOption(this); 9388 } 9389 @Override 9390 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9391 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOption(this); 9392 else return visitor.visitChildren(this); 9393 } 9394 } 9395 9396 public final OptionContext option() throws RecognitionException { 9397 OptionContext _localctx = new OptionContext(_ctx, getState()); 9398 enterRule(_localctx, 82, RULE_option); 9399 try { 9400 int _alt; 9401 enterOuterAlt(_localctx, 1); 9402 { 9403 setState(1089); 9404 optionTagOpen(); 9405 setState(1129); 9406 _errHandler.sync(this); 9407 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 9408 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 9409 if ( _alt==1 ) { 9410 { 9411 setState(1127); 9412 _errHandler.sync(this); 9413 switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { 9414 case 1: 9415 { 9416 setState(1090); 9417 htmlTag(); 9418 } 9419 break; 9420 case 2: 9421 { 9422 setState(1091); 9423 singletonTag(); 9424 } 9425 break; 9426 case 3: 9427 { 9428 setState(1092); 9429 paragraph(); 9430 } 9431 break; 9432 case 4: 9433 { 9434 setState(1093); 9435 li(); 9436 } 9437 break; 9438 case 5: 9439 { 9440 setState(1094); 9441 tr(); 9442 } 9443 break; 9444 case 6: 9445 { 9446 setState(1095); 9447 td(); 9448 } 9449 break; 9450 case 7: 9451 { 9452 setState(1096); 9453 th(); 9454 } 9455 break; 9456 case 8: 9457 { 9458 setState(1097); 9459 body(); 9460 } 9461 break; 9462 case 9: 9463 { 9464 setState(1098); 9465 colgroup(); 9466 } 9467 break; 9468 case 10: 9469 { 9470 setState(1099); 9471 dd(); 9472 } 9473 break; 9474 case 11: 9475 { 9476 setState(1100); 9477 dt(); 9478 } 9479 break; 9480 case 12: 9481 { 9482 setState(1101); 9483 head(); 9484 } 9485 break; 9486 case 13: 9487 { 9488 setState(1102); 9489 html(); 9490 } 9491 break; 9492 case 14: 9493 { 9494 setState(1103); 9495 tbody(); 9496 } 9497 break; 9498 case 15: 9499 { 9500 setState(1104); 9501 thead(); 9502 } 9503 break; 9504 case 16: 9505 { 9506 setState(1105); 9507 tfoot(); 9508 } 9509 break; 9510 case 17: 9511 { 9512 setState(1106); 9513 pTagOpen(); 9514 } 9515 break; 9516 case 18: 9517 { 9518 setState(1107); 9519 liTagOpen(); 9520 } 9521 break; 9522 case 19: 9523 { 9524 setState(1108); 9525 trTagOpen(); 9526 } 9527 break; 9528 case 20: 9529 { 9530 setState(1109); 9531 tdTagOpen(); 9532 } 9533 break; 9534 case 21: 9535 { 9536 setState(1110); 9537 thTagOpen(); 9538 } 9539 break; 9540 case 22: 9541 { 9542 setState(1111); 9543 bodyTagOpen(); 9544 } 9545 break; 9546 case 23: 9547 { 9548 setState(1112); 9549 colgroupTagOpen(); 9550 } 9551 break; 9552 case 24: 9553 { 9554 setState(1113); 9555 ddTagOpen(); 9556 } 9557 break; 9558 case 25: 9559 { 9560 setState(1114); 9561 dtTagOpen(); 9562 } 9563 break; 9564 case 26: 9565 { 9566 setState(1115); 9567 headTagOpen(); 9568 } 9569 break; 9570 case 27: 9571 { 9572 setState(1116); 9573 htmlTagOpen(); 9574 } 9575 break; 9576 case 28: 9577 { 9578 setState(1117); 9579 tbodyTagOpen(); 9580 } 9581 break; 9582 case 29: 9583 { 9584 setState(1118); 9585 theadTagOpen(); 9586 } 9587 break; 9588 case 30: 9589 { 9590 setState(1119); 9591 tfootTagOpen(); 9592 } 9593 break; 9594 case 31: 9595 { 9596 { 9597 setState(1120); 9598 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 9599 setState(1121); 9600 match(LEADING_ASTERISK); 9601 } 9602 } 9603 break; 9604 case 32: 9605 { 9606 setState(1122); 9607 htmlComment(); 9608 } 9609 break; 9610 case 33: 9611 { 9612 setState(1123); 9613 match(CDATA); 9614 } 9615 break; 9616 case 34: 9617 { 9618 setState(1124); 9619 match(NEWLINE); 9620 } 9621 break; 9622 case 35: 9623 { 9624 setState(1125); 9625 text(); 9626 } 9627 break; 9628 case 36: 9629 { 9630 setState(1126); 9631 javadocInlineTag(); 9632 } 9633 break; 9634 } 9635 } 9636 } 9637 setState(1131); 9638 _errHandler.sync(this); 9639 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 9640 } 9641 setState(1132); 9642 optionTagClose(); 9643 } 9644 } 9645 catch (RecognitionException re) { 9646 _localctx.exception = re; 9647 _errHandler.reportError(this, re); 9648 _errHandler.recover(this, re); 9649 } 9650 finally { 9651 exitRule(); 9652 } 9653 return _localctx; 9654 } 9655 9656 public static class TbodyTagOpenContext extends ParserRuleContext { 9657 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9658 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9659 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9660 public List<AttributeContext> attribute() { 9661 return getRuleContexts(AttributeContext.class); 9662 } 9663 public AttributeContext attribute(int i) { 9664 return getRuleContext(AttributeContext.class,i); 9665 } 9666 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9667 public TerminalNode NEWLINE(int i) { 9668 return getToken(JavadocParser.NEWLINE, i); 9669 } 9670 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9671 public TerminalNode LEADING_ASTERISK(int i) { 9672 return getToken(JavadocParser.LEADING_ASTERISK, i); 9673 } 9674 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9675 public TerminalNode WS(int i) { 9676 return getToken(JavadocParser.WS, i); 9677 } 9678 public TbodyTagOpenContext(ParserRuleContext parent, int invokingState) { 9679 super(parent, invokingState); 9680 } 9681 @Override public int getRuleIndex() { return RULE_tbodyTagOpen; } 9682 @Override 9683 public void enterRule(ParseTreeListener listener) { 9684 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagOpen(this); 9685 } 9686 @Override 9687 public void exitRule(ParseTreeListener listener) { 9688 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagOpen(this); 9689 } 9690 @Override 9691 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9692 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagOpen(this); 9693 else return visitor.visitChildren(this); 9694 } 9695 } 9696 9697 public final TbodyTagOpenContext tbodyTagOpen() throws RecognitionException { 9698 TbodyTagOpenContext _localctx = new TbodyTagOpenContext(_ctx, getState()); 9699 enterRule(_localctx, 84, RULE_tbodyTagOpen); 9700 int _la; 9701 try { 9702 enterOuterAlt(_localctx, 1); 9703 { 9704 setState(1134); 9705 match(OPEN); 9706 setState(1135); 9707 match(TBODY_HTML_TAG_NAME); 9708 setState(1142); 9709 _errHandler.sync(this); 9710 _la = _input.LA(1); 9711 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9712 { 9713 setState(1140); 9714 switch (_input.LA(1)) { 9715 case HTML_TAG_NAME: 9716 { 9717 setState(1136); 9718 attribute(); 9719 } 9720 break; 9721 case NEWLINE: 9722 { 9723 setState(1137); 9724 match(NEWLINE); 9725 } 9726 break; 9727 case LEADING_ASTERISK: 9728 { 9729 setState(1138); 9730 match(LEADING_ASTERISK); 9731 } 9732 break; 9733 case WS: 9734 { 9735 setState(1139); 9736 match(WS); 9737 } 9738 break; 9739 default: 9740 throw new NoViableAltException(this); 9741 } 9742 } 9743 setState(1144); 9744 _errHandler.sync(this); 9745 _la = _input.LA(1); 9746 } 9747 setState(1145); 9748 match(CLOSE); 9749 } 9750 } 9751 catch (RecognitionException re) { 9752 _localctx.exception = re; 9753 _errHandler.reportError(this, re); 9754 _errHandler.recover(this, re); 9755 } 9756 finally { 9757 exitRule(); 9758 } 9759 return _localctx; 9760 } 9761 9762 public static class TbodyTagCloseContext extends ParserRuleContext { 9763 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9764 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9765 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9766 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9767 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9768 public TerminalNode NEWLINE(int i) { 9769 return getToken(JavadocParser.NEWLINE, i); 9770 } 9771 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9772 public TerminalNode LEADING_ASTERISK(int i) { 9773 return getToken(JavadocParser.LEADING_ASTERISK, i); 9774 } 9775 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9776 public TerminalNode WS(int i) { 9777 return getToken(JavadocParser.WS, i); 9778 } 9779 public TbodyTagCloseContext(ParserRuleContext parent, int invokingState) { 9780 super(parent, invokingState); 9781 } 9782 @Override public int getRuleIndex() { return RULE_tbodyTagClose; } 9783 @Override 9784 public void enterRule(ParseTreeListener listener) { 9785 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagClose(this); 9786 } 9787 @Override 9788 public void exitRule(ParseTreeListener listener) { 9789 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagClose(this); 9790 } 9791 @Override 9792 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9793 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagClose(this); 9794 else return visitor.visitChildren(this); 9795 } 9796 } 9797 9798 public final TbodyTagCloseContext tbodyTagClose() throws RecognitionException { 9799 TbodyTagCloseContext _localctx = new TbodyTagCloseContext(_ctx, getState()); 9800 enterRule(_localctx, 86, RULE_tbodyTagClose); 9801 int _la; 9802 try { 9803 enterOuterAlt(_localctx, 1); 9804 { 9805 setState(1147); 9806 match(OPEN); 9807 setState(1148); 9808 match(SLASH); 9809 setState(1149); 9810 match(TBODY_HTML_TAG_NAME); 9811 setState(1153); 9812 _errHandler.sync(this); 9813 _la = _input.LA(1); 9814 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9815 { 9816 { 9817 setState(1150); 9818 _la = _input.LA(1); 9819 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9820 _errHandler.recoverInline(this); 9821 } else { 9822 consume(); 9823 } 9824 } 9825 } 9826 setState(1155); 9827 _errHandler.sync(this); 9828 _la = _input.LA(1); 9829 } 9830 setState(1156); 9831 match(CLOSE); 9832 } 9833 } 9834 catch (RecognitionException re) { 9835 _localctx.exception = re; 9836 _errHandler.reportError(this, re); 9837 _errHandler.recover(this, re); 9838 } 9839 finally { 9840 exitRule(); 9841 } 9842 return _localctx; 9843 } 9844 9845 public static class TbodyContext extends ParserRuleContext { 9846 public TbodyTagOpenContext tbodyTagOpen() { 9847 return getRuleContext(TbodyTagOpenContext.class,0); 9848 } 9849 public TbodyTagCloseContext tbodyTagClose() { 9850 return getRuleContext(TbodyTagCloseContext.class,0); 9851 } 9852 public List<HtmlTagContext> htmlTag() { 9853 return getRuleContexts(HtmlTagContext.class); 9854 } 9855 public HtmlTagContext htmlTag(int i) { 9856 return getRuleContext(HtmlTagContext.class,i); 9857 } 9858 public List<SingletonTagContext> singletonTag() { 9859 return getRuleContexts(SingletonTagContext.class); 9860 } 9861 public SingletonTagContext singletonTag(int i) { 9862 return getRuleContext(SingletonTagContext.class,i); 9863 } 9864 public List<ParagraphContext> paragraph() { 9865 return getRuleContexts(ParagraphContext.class); 9866 } 9867 public ParagraphContext paragraph(int i) { 9868 return getRuleContext(ParagraphContext.class,i); 9869 } 9870 public List<LiContext> li() { 9871 return getRuleContexts(LiContext.class); 9872 } 9873 public LiContext li(int i) { 9874 return getRuleContext(LiContext.class,i); 9875 } 9876 public List<TrContext> tr() { 9877 return getRuleContexts(TrContext.class); 9878 } 9879 public TrContext tr(int i) { 9880 return getRuleContext(TrContext.class,i); 9881 } 9882 public List<TdContext> td() { 9883 return getRuleContexts(TdContext.class); 9884 } 9885 public TdContext td(int i) { 9886 return getRuleContext(TdContext.class,i); 9887 } 9888 public List<ThContext> th() { 9889 return getRuleContexts(ThContext.class); 9890 } 9891 public ThContext th(int i) { 9892 return getRuleContext(ThContext.class,i); 9893 } 9894 public List<BodyContext> body() { 9895 return getRuleContexts(BodyContext.class); 9896 } 9897 public BodyContext body(int i) { 9898 return getRuleContext(BodyContext.class,i); 9899 } 9900 public List<ColgroupContext> colgroup() { 9901 return getRuleContexts(ColgroupContext.class); 9902 } 9903 public ColgroupContext colgroup(int i) { 9904 return getRuleContext(ColgroupContext.class,i); 9905 } 9906 public List<DdContext> dd() { 9907 return getRuleContexts(DdContext.class); 9908 } 9909 public DdContext dd(int i) { 9910 return getRuleContext(DdContext.class,i); 9911 } 9912 public List<DtContext> dt() { 9913 return getRuleContexts(DtContext.class); 9914 } 9915 public DtContext dt(int i) { 9916 return getRuleContext(DtContext.class,i); 9917 } 9918 public List<HeadContext> head() { 9919 return getRuleContexts(HeadContext.class); 9920 } 9921 public HeadContext head(int i) { 9922 return getRuleContext(HeadContext.class,i); 9923 } 9924 public List<HtmlContext> html() { 9925 return getRuleContexts(HtmlContext.class); 9926 } 9927 public HtmlContext html(int i) { 9928 return getRuleContext(HtmlContext.class,i); 9929 } 9930 public List<OptionContext> option() { 9931 return getRuleContexts(OptionContext.class); 9932 } 9933 public OptionContext option(int i) { 9934 return getRuleContext(OptionContext.class,i); 9935 } 9936 public List<TheadContext> thead() { 9937 return getRuleContexts(TheadContext.class); 9938 } 9939 public TheadContext thead(int i) { 9940 return getRuleContext(TheadContext.class,i); 9941 } 9942 public List<TfootContext> tfoot() { 9943 return getRuleContexts(TfootContext.class); 9944 } 9945 public TfootContext tfoot(int i) { 9946 return getRuleContext(TfootContext.class,i); 9947 } 9948 public List<PTagOpenContext> pTagOpen() { 9949 return getRuleContexts(PTagOpenContext.class); 9950 } 9951 public PTagOpenContext pTagOpen(int i) { 9952 return getRuleContext(PTagOpenContext.class,i); 9953 } 9954 public List<LiTagOpenContext> liTagOpen() { 9955 return getRuleContexts(LiTagOpenContext.class); 9956 } 9957 public LiTagOpenContext liTagOpen(int i) { 9958 return getRuleContext(LiTagOpenContext.class,i); 9959 } 9960 public List<TrTagOpenContext> trTagOpen() { 9961 return getRuleContexts(TrTagOpenContext.class); 9962 } 9963 public TrTagOpenContext trTagOpen(int i) { 9964 return getRuleContext(TrTagOpenContext.class,i); 9965 } 9966 public List<TdTagOpenContext> tdTagOpen() { 9967 return getRuleContexts(TdTagOpenContext.class); 9968 } 9969 public TdTagOpenContext tdTagOpen(int i) { 9970 return getRuleContext(TdTagOpenContext.class,i); 9971 } 9972 public List<ThTagOpenContext> thTagOpen() { 9973 return getRuleContexts(ThTagOpenContext.class); 9974 } 9975 public ThTagOpenContext thTagOpen(int i) { 9976 return getRuleContext(ThTagOpenContext.class,i); 9977 } 9978 public List<BodyTagOpenContext> bodyTagOpen() { 9979 return getRuleContexts(BodyTagOpenContext.class); 9980 } 9981 public BodyTagOpenContext bodyTagOpen(int i) { 9982 return getRuleContext(BodyTagOpenContext.class,i); 9983 } 9984 public List<ColgroupTagOpenContext> colgroupTagOpen() { 9985 return getRuleContexts(ColgroupTagOpenContext.class); 9986 } 9987 public ColgroupTagOpenContext colgroupTagOpen(int i) { 9988 return getRuleContext(ColgroupTagOpenContext.class,i); 9989 } 9990 public List<DdTagOpenContext> ddTagOpen() { 9991 return getRuleContexts(DdTagOpenContext.class); 9992 } 9993 public DdTagOpenContext ddTagOpen(int i) { 9994 return getRuleContext(DdTagOpenContext.class,i); 9995 } 9996 public List<DtTagOpenContext> dtTagOpen() { 9997 return getRuleContexts(DtTagOpenContext.class); 9998 } 9999 public DtTagOpenContext dtTagOpen(int i) { 10000 return getRuleContext(DtTagOpenContext.class,i); 10001 } 10002 public List<HeadTagOpenContext> headTagOpen() { 10003 return getRuleContexts(HeadTagOpenContext.class); 10004 } 10005 public HeadTagOpenContext headTagOpen(int i) { 10006 return getRuleContext(HeadTagOpenContext.class,i); 10007 } 10008 public List<HtmlTagOpenContext> htmlTagOpen() { 10009 return getRuleContexts(HtmlTagOpenContext.class); 10010 } 10011 public HtmlTagOpenContext htmlTagOpen(int i) { 10012 return getRuleContext(HtmlTagOpenContext.class,i); 10013 } 10014 public List<OptionTagOpenContext> optionTagOpen() { 10015 return getRuleContexts(OptionTagOpenContext.class); 10016 } 10017 public OptionTagOpenContext optionTagOpen(int i) { 10018 return getRuleContext(OptionTagOpenContext.class,i); 10019 } 10020 public List<TheadTagOpenContext> theadTagOpen() { 10021 return getRuleContexts(TheadTagOpenContext.class); 10022 } 10023 public TheadTagOpenContext theadTagOpen(int i) { 10024 return getRuleContext(TheadTagOpenContext.class,i); 10025 } 10026 public List<TfootTagOpenContext> tfootTagOpen() { 10027 return getRuleContexts(TfootTagOpenContext.class); 10028 } 10029 public TfootTagOpenContext tfootTagOpen(int i) { 10030 return getRuleContext(TfootTagOpenContext.class,i); 10031 } 10032 public List<HtmlCommentContext> htmlComment() { 10033 return getRuleContexts(HtmlCommentContext.class); 10034 } 10035 public HtmlCommentContext htmlComment(int i) { 10036 return getRuleContext(HtmlCommentContext.class,i); 10037 } 10038 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10039 public TerminalNode CDATA(int i) { 10040 return getToken(JavadocParser.CDATA, i); 10041 } 10042 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10043 public TerminalNode NEWLINE(int i) { 10044 return getToken(JavadocParser.NEWLINE, i); 10045 } 10046 public List<TextContext> text() { 10047 return getRuleContexts(TextContext.class); 10048 } 10049 public TextContext text(int i) { 10050 return getRuleContext(TextContext.class,i); 10051 } 10052 public List<JavadocInlineTagContext> javadocInlineTag() { 10053 return getRuleContexts(JavadocInlineTagContext.class); 10054 } 10055 public JavadocInlineTagContext javadocInlineTag(int i) { 10056 return getRuleContext(JavadocInlineTagContext.class,i); 10057 } 10058 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10059 public TerminalNode LEADING_ASTERISK(int i) { 10060 return getToken(JavadocParser.LEADING_ASTERISK, i); 10061 } 10062 public TbodyContext(ParserRuleContext parent, int invokingState) { 10063 super(parent, invokingState); 10064 } 10065 @Override public int getRuleIndex() { return RULE_tbody; } 10066 @Override 10067 public void enterRule(ParseTreeListener listener) { 10068 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbody(this); 10069 } 10070 @Override 10071 public void exitRule(ParseTreeListener listener) { 10072 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbody(this); 10073 } 10074 @Override 10075 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10076 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbody(this); 10077 else return visitor.visitChildren(this); 10078 } 10079 } 10080 10081 public final TbodyContext tbody() throws RecognitionException { 10082 TbodyContext _localctx = new TbodyContext(_ctx, getState()); 10083 enterRule(_localctx, 88, RULE_tbody); 10084 try { 10085 int _alt; 10086 enterOuterAlt(_localctx, 1); 10087 { 10088 setState(1158); 10089 tbodyTagOpen(); 10090 setState(1198); 10091 _errHandler.sync(this); 10092 _alt = getInterpreter().adaptivePredict(_input,81,_ctx); 10093 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10094 if ( _alt==1 ) { 10095 { 10096 setState(1196); 10097 _errHandler.sync(this); 10098 switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) { 10099 case 1: 10100 { 10101 setState(1159); 10102 htmlTag(); 10103 } 10104 break; 10105 case 2: 10106 { 10107 setState(1160); 10108 singletonTag(); 10109 } 10110 break; 10111 case 3: 10112 { 10113 setState(1161); 10114 paragraph(); 10115 } 10116 break; 10117 case 4: 10118 { 10119 setState(1162); 10120 li(); 10121 } 10122 break; 10123 case 5: 10124 { 10125 setState(1163); 10126 tr(); 10127 } 10128 break; 10129 case 6: 10130 { 10131 setState(1164); 10132 td(); 10133 } 10134 break; 10135 case 7: 10136 { 10137 setState(1165); 10138 th(); 10139 } 10140 break; 10141 case 8: 10142 { 10143 setState(1166); 10144 body(); 10145 } 10146 break; 10147 case 9: 10148 { 10149 setState(1167); 10150 colgroup(); 10151 } 10152 break; 10153 case 10: 10154 { 10155 setState(1168); 10156 dd(); 10157 } 10158 break; 10159 case 11: 10160 { 10161 setState(1169); 10162 dt(); 10163 } 10164 break; 10165 case 12: 10166 { 10167 setState(1170); 10168 head(); 10169 } 10170 break; 10171 case 13: 10172 { 10173 setState(1171); 10174 html(); 10175 } 10176 break; 10177 case 14: 10178 { 10179 setState(1172); 10180 option(); 10181 } 10182 break; 10183 case 15: 10184 { 10185 setState(1173); 10186 thead(); 10187 } 10188 break; 10189 case 16: 10190 { 10191 setState(1174); 10192 tfoot(); 10193 } 10194 break; 10195 case 17: 10196 { 10197 setState(1175); 10198 pTagOpen(); 10199 } 10200 break; 10201 case 18: 10202 { 10203 setState(1176); 10204 liTagOpen(); 10205 } 10206 break; 10207 case 19: 10208 { 10209 setState(1177); 10210 trTagOpen(); 10211 } 10212 break; 10213 case 20: 10214 { 10215 setState(1178); 10216 tdTagOpen(); 10217 } 10218 break; 10219 case 21: 10220 { 10221 setState(1179); 10222 thTagOpen(); 10223 } 10224 break; 10225 case 22: 10226 { 10227 setState(1180); 10228 bodyTagOpen(); 10229 } 10230 break; 10231 case 23: 10232 { 10233 setState(1181); 10234 colgroupTagOpen(); 10235 } 10236 break; 10237 case 24: 10238 { 10239 setState(1182); 10240 ddTagOpen(); 10241 } 10242 break; 10243 case 25: 10244 { 10245 setState(1183); 10246 dtTagOpen(); 10247 } 10248 break; 10249 case 26: 10250 { 10251 setState(1184); 10252 headTagOpen(); 10253 } 10254 break; 10255 case 27: 10256 { 10257 setState(1185); 10258 htmlTagOpen(); 10259 } 10260 break; 10261 case 28: 10262 { 10263 setState(1186); 10264 optionTagOpen(); 10265 } 10266 break; 10267 case 29: 10268 { 10269 setState(1187); 10270 theadTagOpen(); 10271 } 10272 break; 10273 case 30: 10274 { 10275 setState(1188); 10276 tfootTagOpen(); 10277 } 10278 break; 10279 case 31: 10280 { 10281 { 10282 setState(1189); 10283 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10284 setState(1190); 10285 match(LEADING_ASTERISK); 10286 } 10287 } 10288 break; 10289 case 32: 10290 { 10291 setState(1191); 10292 htmlComment(); 10293 } 10294 break; 10295 case 33: 10296 { 10297 setState(1192); 10298 match(CDATA); 10299 } 10300 break; 10301 case 34: 10302 { 10303 setState(1193); 10304 match(NEWLINE); 10305 } 10306 break; 10307 case 35: 10308 { 10309 setState(1194); 10310 text(); 10311 } 10312 break; 10313 case 36: 10314 { 10315 setState(1195); 10316 javadocInlineTag(); 10317 } 10318 break; 10319 } 10320 } 10321 } 10322 setState(1200); 10323 _errHandler.sync(this); 10324 _alt = getInterpreter().adaptivePredict(_input,81,_ctx); 10325 } 10326 setState(1201); 10327 tbodyTagClose(); 10328 } 10329 } 10330 catch (RecognitionException re) { 10331 _localctx.exception = re; 10332 _errHandler.reportError(this, re); 10333 _errHandler.recover(this, re); 10334 } 10335 finally { 10336 exitRule(); 10337 } 10338 return _localctx; 10339 } 10340 10341 public static class TfootTagOpenContext extends ParserRuleContext { 10342 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10343 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 10344 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10345 public List<AttributeContext> attribute() { 10346 return getRuleContexts(AttributeContext.class); 10347 } 10348 public AttributeContext attribute(int i) { 10349 return getRuleContext(AttributeContext.class,i); 10350 } 10351 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10352 public TerminalNode NEWLINE(int i) { 10353 return getToken(JavadocParser.NEWLINE, i); 10354 } 10355 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10356 public TerminalNode LEADING_ASTERISK(int i) { 10357 return getToken(JavadocParser.LEADING_ASTERISK, i); 10358 } 10359 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10360 public TerminalNode WS(int i) { 10361 return getToken(JavadocParser.WS, i); 10362 } 10363 public TfootTagOpenContext(ParserRuleContext parent, int invokingState) { 10364 super(parent, invokingState); 10365 } 10366 @Override public int getRuleIndex() { return RULE_tfootTagOpen; } 10367 @Override 10368 public void enterRule(ParseTreeListener listener) { 10369 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagOpen(this); 10370 } 10371 @Override 10372 public void exitRule(ParseTreeListener listener) { 10373 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagOpen(this); 10374 } 10375 @Override 10376 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10377 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagOpen(this); 10378 else return visitor.visitChildren(this); 10379 } 10380 } 10381 10382 public final TfootTagOpenContext tfootTagOpen() throws RecognitionException { 10383 TfootTagOpenContext _localctx = new TfootTagOpenContext(_ctx, getState()); 10384 enterRule(_localctx, 90, RULE_tfootTagOpen); 10385 int _la; 10386 try { 10387 enterOuterAlt(_localctx, 1); 10388 { 10389 setState(1203); 10390 match(OPEN); 10391 setState(1204); 10392 match(TFOOT_HTML_TAG_NAME); 10393 setState(1211); 10394 _errHandler.sync(this); 10395 _la = _input.LA(1); 10396 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 10397 { 10398 setState(1209); 10399 switch (_input.LA(1)) { 10400 case HTML_TAG_NAME: 10401 { 10402 setState(1205); 10403 attribute(); 10404 } 10405 break; 10406 case NEWLINE: 10407 { 10408 setState(1206); 10409 match(NEWLINE); 10410 } 10411 break; 10412 case LEADING_ASTERISK: 10413 { 10414 setState(1207); 10415 match(LEADING_ASTERISK); 10416 } 10417 break; 10418 case WS: 10419 { 10420 setState(1208); 10421 match(WS); 10422 } 10423 break; 10424 default: 10425 throw new NoViableAltException(this); 10426 } 10427 } 10428 setState(1213); 10429 _errHandler.sync(this); 10430 _la = _input.LA(1); 10431 } 10432 setState(1214); 10433 match(CLOSE); 10434 } 10435 } 10436 catch (RecognitionException re) { 10437 _localctx.exception = re; 10438 _errHandler.reportError(this, re); 10439 _errHandler.recover(this, re); 10440 } 10441 finally { 10442 exitRule(); 10443 } 10444 return _localctx; 10445 } 10446 10447 public static class TfootTagCloseContext extends ParserRuleContext { 10448 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10449 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 10450 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 10451 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10452 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10453 public TerminalNode NEWLINE(int i) { 10454 return getToken(JavadocParser.NEWLINE, i); 10455 } 10456 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10457 public TerminalNode LEADING_ASTERISK(int i) { 10458 return getToken(JavadocParser.LEADING_ASTERISK, i); 10459 } 10460 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10461 public TerminalNode WS(int i) { 10462 return getToken(JavadocParser.WS, i); 10463 } 10464 public TfootTagCloseContext(ParserRuleContext parent, int invokingState) { 10465 super(parent, invokingState); 10466 } 10467 @Override public int getRuleIndex() { return RULE_tfootTagClose; } 10468 @Override 10469 public void enterRule(ParseTreeListener listener) { 10470 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagClose(this); 10471 } 10472 @Override 10473 public void exitRule(ParseTreeListener listener) { 10474 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagClose(this); 10475 } 10476 @Override 10477 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10478 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagClose(this); 10479 else return visitor.visitChildren(this); 10480 } 10481 } 10482 10483 public final TfootTagCloseContext tfootTagClose() throws RecognitionException { 10484 TfootTagCloseContext _localctx = new TfootTagCloseContext(_ctx, getState()); 10485 enterRule(_localctx, 92, RULE_tfootTagClose); 10486 int _la; 10487 try { 10488 enterOuterAlt(_localctx, 1); 10489 { 10490 setState(1216); 10491 match(OPEN); 10492 setState(1217); 10493 match(SLASH); 10494 setState(1218); 10495 match(TFOOT_HTML_TAG_NAME); 10496 setState(1222); 10497 _errHandler.sync(this); 10498 _la = _input.LA(1); 10499 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10500 { 10501 { 10502 setState(1219); 10503 _la = _input.LA(1); 10504 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10505 _errHandler.recoverInline(this); 10506 } else { 10507 consume(); 10508 } 10509 } 10510 } 10511 setState(1224); 10512 _errHandler.sync(this); 10513 _la = _input.LA(1); 10514 } 10515 setState(1225); 10516 match(CLOSE); 10517 } 10518 } 10519 catch (RecognitionException re) { 10520 _localctx.exception = re; 10521 _errHandler.reportError(this, re); 10522 _errHandler.recover(this, re); 10523 } 10524 finally { 10525 exitRule(); 10526 } 10527 return _localctx; 10528 } 10529 10530 public static class TfootContext extends ParserRuleContext { 10531 public TfootTagOpenContext tfootTagOpen() { 10532 return getRuleContext(TfootTagOpenContext.class,0); 10533 } 10534 public TfootTagCloseContext tfootTagClose() { 10535 return getRuleContext(TfootTagCloseContext.class,0); 10536 } 10537 public List<HtmlTagContext> htmlTag() { 10538 return getRuleContexts(HtmlTagContext.class); 10539 } 10540 public HtmlTagContext htmlTag(int i) { 10541 return getRuleContext(HtmlTagContext.class,i); 10542 } 10543 public List<SingletonTagContext> singletonTag() { 10544 return getRuleContexts(SingletonTagContext.class); 10545 } 10546 public SingletonTagContext singletonTag(int i) { 10547 return getRuleContext(SingletonTagContext.class,i); 10548 } 10549 public List<ParagraphContext> paragraph() { 10550 return getRuleContexts(ParagraphContext.class); 10551 } 10552 public ParagraphContext paragraph(int i) { 10553 return getRuleContext(ParagraphContext.class,i); 10554 } 10555 public List<LiContext> li() { 10556 return getRuleContexts(LiContext.class); 10557 } 10558 public LiContext li(int i) { 10559 return getRuleContext(LiContext.class,i); 10560 } 10561 public List<TrContext> tr() { 10562 return getRuleContexts(TrContext.class); 10563 } 10564 public TrContext tr(int i) { 10565 return getRuleContext(TrContext.class,i); 10566 } 10567 public List<TdContext> td() { 10568 return getRuleContexts(TdContext.class); 10569 } 10570 public TdContext td(int i) { 10571 return getRuleContext(TdContext.class,i); 10572 } 10573 public List<ThContext> th() { 10574 return getRuleContexts(ThContext.class); 10575 } 10576 public ThContext th(int i) { 10577 return getRuleContext(ThContext.class,i); 10578 } 10579 public List<BodyContext> body() { 10580 return getRuleContexts(BodyContext.class); 10581 } 10582 public BodyContext body(int i) { 10583 return getRuleContext(BodyContext.class,i); 10584 } 10585 public List<ColgroupContext> colgroup() { 10586 return getRuleContexts(ColgroupContext.class); 10587 } 10588 public ColgroupContext colgroup(int i) { 10589 return getRuleContext(ColgroupContext.class,i); 10590 } 10591 public List<DdContext> dd() { 10592 return getRuleContexts(DdContext.class); 10593 } 10594 public DdContext dd(int i) { 10595 return getRuleContext(DdContext.class,i); 10596 } 10597 public List<DtContext> dt() { 10598 return getRuleContexts(DtContext.class); 10599 } 10600 public DtContext dt(int i) { 10601 return getRuleContext(DtContext.class,i); 10602 } 10603 public List<HeadContext> head() { 10604 return getRuleContexts(HeadContext.class); 10605 } 10606 public HeadContext head(int i) { 10607 return getRuleContext(HeadContext.class,i); 10608 } 10609 public List<HtmlContext> html() { 10610 return getRuleContexts(HtmlContext.class); 10611 } 10612 public HtmlContext html(int i) { 10613 return getRuleContext(HtmlContext.class,i); 10614 } 10615 public List<OptionContext> option() { 10616 return getRuleContexts(OptionContext.class); 10617 } 10618 public OptionContext option(int i) { 10619 return getRuleContext(OptionContext.class,i); 10620 } 10621 public List<TbodyContext> tbody() { 10622 return getRuleContexts(TbodyContext.class); 10623 } 10624 public TbodyContext tbody(int i) { 10625 return getRuleContext(TbodyContext.class,i); 10626 } 10627 public List<TheadContext> thead() { 10628 return getRuleContexts(TheadContext.class); 10629 } 10630 public TheadContext thead(int i) { 10631 return getRuleContext(TheadContext.class,i); 10632 } 10633 public List<PTagOpenContext> pTagOpen() { 10634 return getRuleContexts(PTagOpenContext.class); 10635 } 10636 public PTagOpenContext pTagOpen(int i) { 10637 return getRuleContext(PTagOpenContext.class,i); 10638 } 10639 public List<LiTagOpenContext> liTagOpen() { 10640 return getRuleContexts(LiTagOpenContext.class); 10641 } 10642 public LiTagOpenContext liTagOpen(int i) { 10643 return getRuleContext(LiTagOpenContext.class,i); 10644 } 10645 public List<TrTagOpenContext> trTagOpen() { 10646 return getRuleContexts(TrTagOpenContext.class); 10647 } 10648 public TrTagOpenContext trTagOpen(int i) { 10649 return getRuleContext(TrTagOpenContext.class,i); 10650 } 10651 public List<TdTagOpenContext> tdTagOpen() { 10652 return getRuleContexts(TdTagOpenContext.class); 10653 } 10654 public TdTagOpenContext tdTagOpen(int i) { 10655 return getRuleContext(TdTagOpenContext.class,i); 10656 } 10657 public List<ThTagOpenContext> thTagOpen() { 10658 return getRuleContexts(ThTagOpenContext.class); 10659 } 10660 public ThTagOpenContext thTagOpen(int i) { 10661 return getRuleContext(ThTagOpenContext.class,i); 10662 } 10663 public List<BodyTagOpenContext> bodyTagOpen() { 10664 return getRuleContexts(BodyTagOpenContext.class); 10665 } 10666 public BodyTagOpenContext bodyTagOpen(int i) { 10667 return getRuleContext(BodyTagOpenContext.class,i); 10668 } 10669 public List<ColgroupTagOpenContext> colgroupTagOpen() { 10670 return getRuleContexts(ColgroupTagOpenContext.class); 10671 } 10672 public ColgroupTagOpenContext colgroupTagOpen(int i) { 10673 return getRuleContext(ColgroupTagOpenContext.class,i); 10674 } 10675 public List<DdTagOpenContext> ddTagOpen() { 10676 return getRuleContexts(DdTagOpenContext.class); 10677 } 10678 public DdTagOpenContext ddTagOpen(int i) { 10679 return getRuleContext(DdTagOpenContext.class,i); 10680 } 10681 public List<DtTagOpenContext> dtTagOpen() { 10682 return getRuleContexts(DtTagOpenContext.class); 10683 } 10684 public DtTagOpenContext dtTagOpen(int i) { 10685 return getRuleContext(DtTagOpenContext.class,i); 10686 } 10687 public List<HeadTagOpenContext> headTagOpen() { 10688 return getRuleContexts(HeadTagOpenContext.class); 10689 } 10690 public HeadTagOpenContext headTagOpen(int i) { 10691 return getRuleContext(HeadTagOpenContext.class,i); 10692 } 10693 public List<HtmlTagOpenContext> htmlTagOpen() { 10694 return getRuleContexts(HtmlTagOpenContext.class); 10695 } 10696 public HtmlTagOpenContext htmlTagOpen(int i) { 10697 return getRuleContext(HtmlTagOpenContext.class,i); 10698 } 10699 public List<OptionTagOpenContext> optionTagOpen() { 10700 return getRuleContexts(OptionTagOpenContext.class); 10701 } 10702 public OptionTagOpenContext optionTagOpen(int i) { 10703 return getRuleContext(OptionTagOpenContext.class,i); 10704 } 10705 public List<TbodyTagOpenContext> tbodyTagOpen() { 10706 return getRuleContexts(TbodyTagOpenContext.class); 10707 } 10708 public TbodyTagOpenContext tbodyTagOpen(int i) { 10709 return getRuleContext(TbodyTagOpenContext.class,i); 10710 } 10711 public List<TheadTagOpenContext> theadTagOpen() { 10712 return getRuleContexts(TheadTagOpenContext.class); 10713 } 10714 public TheadTagOpenContext theadTagOpen(int i) { 10715 return getRuleContext(TheadTagOpenContext.class,i); 10716 } 10717 public List<HtmlCommentContext> htmlComment() { 10718 return getRuleContexts(HtmlCommentContext.class); 10719 } 10720 public HtmlCommentContext htmlComment(int i) { 10721 return getRuleContext(HtmlCommentContext.class,i); 10722 } 10723 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10724 public TerminalNode CDATA(int i) { 10725 return getToken(JavadocParser.CDATA, i); 10726 } 10727 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10728 public TerminalNode NEWLINE(int i) { 10729 return getToken(JavadocParser.NEWLINE, i); 10730 } 10731 public List<TextContext> text() { 10732 return getRuleContexts(TextContext.class); 10733 } 10734 public TextContext text(int i) { 10735 return getRuleContext(TextContext.class,i); 10736 } 10737 public List<JavadocInlineTagContext> javadocInlineTag() { 10738 return getRuleContexts(JavadocInlineTagContext.class); 10739 } 10740 public JavadocInlineTagContext javadocInlineTag(int i) { 10741 return getRuleContext(JavadocInlineTagContext.class,i); 10742 } 10743 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10744 public TerminalNode LEADING_ASTERISK(int i) { 10745 return getToken(JavadocParser.LEADING_ASTERISK, i); 10746 } 10747 public TfootContext(ParserRuleContext parent, int invokingState) { 10748 super(parent, invokingState); 10749 } 10750 @Override public int getRuleIndex() { return RULE_tfoot; } 10751 @Override 10752 public void enterRule(ParseTreeListener listener) { 10753 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfoot(this); 10754 } 10755 @Override 10756 public void exitRule(ParseTreeListener listener) { 10757 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfoot(this); 10758 } 10759 @Override 10760 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10761 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfoot(this); 10762 else return visitor.visitChildren(this); 10763 } 10764 } 10765 10766 public final TfootContext tfoot() throws RecognitionException { 10767 TfootContext _localctx = new TfootContext(_ctx, getState()); 10768 enterRule(_localctx, 94, RULE_tfoot); 10769 try { 10770 int _alt; 10771 enterOuterAlt(_localctx, 1); 10772 { 10773 setState(1227); 10774 tfootTagOpen(); 10775 setState(1267); 10776 _errHandler.sync(this); 10777 _alt = getInterpreter().adaptivePredict(_input,86,_ctx); 10778 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10779 if ( _alt==1 ) { 10780 { 10781 setState(1265); 10782 _errHandler.sync(this); 10783 switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) { 10784 case 1: 10785 { 10786 setState(1228); 10787 htmlTag(); 10788 } 10789 break; 10790 case 2: 10791 { 10792 setState(1229); 10793 singletonTag(); 10794 } 10795 break; 10796 case 3: 10797 { 10798 setState(1230); 10799 paragraph(); 10800 } 10801 break; 10802 case 4: 10803 { 10804 setState(1231); 10805 li(); 10806 } 10807 break; 10808 case 5: 10809 { 10810 setState(1232); 10811 tr(); 10812 } 10813 break; 10814 case 6: 10815 { 10816 setState(1233); 10817 td(); 10818 } 10819 break; 10820 case 7: 10821 { 10822 setState(1234); 10823 th(); 10824 } 10825 break; 10826 case 8: 10827 { 10828 setState(1235); 10829 body(); 10830 } 10831 break; 10832 case 9: 10833 { 10834 setState(1236); 10835 colgroup(); 10836 } 10837 break; 10838 case 10: 10839 { 10840 setState(1237); 10841 dd(); 10842 } 10843 break; 10844 case 11: 10845 { 10846 setState(1238); 10847 dt(); 10848 } 10849 break; 10850 case 12: 10851 { 10852 setState(1239); 10853 head(); 10854 } 10855 break; 10856 case 13: 10857 { 10858 setState(1240); 10859 html(); 10860 } 10861 break; 10862 case 14: 10863 { 10864 setState(1241); 10865 option(); 10866 } 10867 break; 10868 case 15: 10869 { 10870 setState(1242); 10871 tbody(); 10872 } 10873 break; 10874 case 16: 10875 { 10876 setState(1243); 10877 thead(); 10878 } 10879 break; 10880 case 17: 10881 { 10882 setState(1244); 10883 pTagOpen(); 10884 } 10885 break; 10886 case 18: 10887 { 10888 setState(1245); 10889 liTagOpen(); 10890 } 10891 break; 10892 case 19: 10893 { 10894 setState(1246); 10895 trTagOpen(); 10896 } 10897 break; 10898 case 20: 10899 { 10900 setState(1247); 10901 tdTagOpen(); 10902 } 10903 break; 10904 case 21: 10905 { 10906 setState(1248); 10907 thTagOpen(); 10908 } 10909 break; 10910 case 22: 10911 { 10912 setState(1249); 10913 bodyTagOpen(); 10914 } 10915 break; 10916 case 23: 10917 { 10918 setState(1250); 10919 colgroupTagOpen(); 10920 } 10921 break; 10922 case 24: 10923 { 10924 setState(1251); 10925 ddTagOpen(); 10926 } 10927 break; 10928 case 25: 10929 { 10930 setState(1252); 10931 dtTagOpen(); 10932 } 10933 break; 10934 case 26: 10935 { 10936 setState(1253); 10937 headTagOpen(); 10938 } 10939 break; 10940 case 27: 10941 { 10942 setState(1254); 10943 htmlTagOpen(); 10944 } 10945 break; 10946 case 28: 10947 { 10948 setState(1255); 10949 optionTagOpen(); 10950 } 10951 break; 10952 case 29: 10953 { 10954 setState(1256); 10955 tbodyTagOpen(); 10956 } 10957 break; 10958 case 30: 10959 { 10960 setState(1257); 10961 theadTagOpen(); 10962 } 10963 break; 10964 case 31: 10965 { 10966 { 10967 setState(1258); 10968 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10969 setState(1259); 10970 match(LEADING_ASTERISK); 10971 } 10972 } 10973 break; 10974 case 32: 10975 { 10976 setState(1260); 10977 htmlComment(); 10978 } 10979 break; 10980 case 33: 10981 { 10982 setState(1261); 10983 match(CDATA); 10984 } 10985 break; 10986 case 34: 10987 { 10988 setState(1262); 10989 match(NEWLINE); 10990 } 10991 break; 10992 case 35: 10993 { 10994 setState(1263); 10995 text(); 10996 } 10997 break; 10998 case 36: 10999 { 11000 setState(1264); 11001 javadocInlineTag(); 11002 } 11003 break; 11004 } 11005 } 11006 } 11007 setState(1269); 11008 _errHandler.sync(this); 11009 _alt = getInterpreter().adaptivePredict(_input,86,_ctx); 11010 } 11011 setState(1270); 11012 tfootTagClose(); 11013 } 11014 } 11015 catch (RecognitionException re) { 11016 _localctx.exception = re; 11017 _errHandler.reportError(this, re); 11018 _errHandler.recover(this, re); 11019 } 11020 finally { 11021 exitRule(); 11022 } 11023 return _localctx; 11024 } 11025 11026 public static class TheadTagOpenContext extends ParserRuleContext { 11027 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11028 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11029 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11030 public List<AttributeContext> attribute() { 11031 return getRuleContexts(AttributeContext.class); 11032 } 11033 public AttributeContext attribute(int i) { 11034 return getRuleContext(AttributeContext.class,i); 11035 } 11036 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11037 public TerminalNode NEWLINE(int i) { 11038 return getToken(JavadocParser.NEWLINE, i); 11039 } 11040 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11041 public TerminalNode LEADING_ASTERISK(int i) { 11042 return getToken(JavadocParser.LEADING_ASTERISK, i); 11043 } 11044 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11045 public TerminalNode WS(int i) { 11046 return getToken(JavadocParser.WS, i); 11047 } 11048 public TheadTagOpenContext(ParserRuleContext parent, int invokingState) { 11049 super(parent, invokingState); 11050 } 11051 @Override public int getRuleIndex() { return RULE_theadTagOpen; } 11052 @Override 11053 public void enterRule(ParseTreeListener listener) { 11054 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagOpen(this); 11055 } 11056 @Override 11057 public void exitRule(ParseTreeListener listener) { 11058 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagOpen(this); 11059 } 11060 @Override 11061 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11062 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagOpen(this); 11063 else return visitor.visitChildren(this); 11064 } 11065 } 11066 11067 public final TheadTagOpenContext theadTagOpen() throws RecognitionException { 11068 TheadTagOpenContext _localctx = new TheadTagOpenContext(_ctx, getState()); 11069 enterRule(_localctx, 96, RULE_theadTagOpen); 11070 int _la; 11071 try { 11072 enterOuterAlt(_localctx, 1); 11073 { 11074 setState(1272); 11075 match(OPEN); 11076 setState(1273); 11077 match(THEAD_HTML_TAG_NAME); 11078 setState(1280); 11079 _errHandler.sync(this); 11080 _la = _input.LA(1); 11081 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11082 { 11083 setState(1278); 11084 switch (_input.LA(1)) { 11085 case HTML_TAG_NAME: 11086 { 11087 setState(1274); 11088 attribute(); 11089 } 11090 break; 11091 case NEWLINE: 11092 { 11093 setState(1275); 11094 match(NEWLINE); 11095 } 11096 break; 11097 case LEADING_ASTERISK: 11098 { 11099 setState(1276); 11100 match(LEADING_ASTERISK); 11101 } 11102 break; 11103 case WS: 11104 { 11105 setState(1277); 11106 match(WS); 11107 } 11108 break; 11109 default: 11110 throw new NoViableAltException(this); 11111 } 11112 } 11113 setState(1282); 11114 _errHandler.sync(this); 11115 _la = _input.LA(1); 11116 } 11117 setState(1283); 11118 match(CLOSE); 11119 } 11120 } 11121 catch (RecognitionException re) { 11122 _localctx.exception = re; 11123 _errHandler.reportError(this, re); 11124 _errHandler.recover(this, re); 11125 } 11126 finally { 11127 exitRule(); 11128 } 11129 return _localctx; 11130 } 11131 11132 public static class TheadTagCloseContext extends ParserRuleContext { 11133 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11134 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 11135 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11136 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11137 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11138 public TerminalNode NEWLINE(int i) { 11139 return getToken(JavadocParser.NEWLINE, i); 11140 } 11141 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11142 public TerminalNode LEADING_ASTERISK(int i) { 11143 return getToken(JavadocParser.LEADING_ASTERISK, i); 11144 } 11145 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11146 public TerminalNode WS(int i) { 11147 return getToken(JavadocParser.WS, i); 11148 } 11149 public TheadTagCloseContext(ParserRuleContext parent, int invokingState) { 11150 super(parent, invokingState); 11151 } 11152 @Override public int getRuleIndex() { return RULE_theadTagClose; } 11153 @Override 11154 public void enterRule(ParseTreeListener listener) { 11155 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagClose(this); 11156 } 11157 @Override 11158 public void exitRule(ParseTreeListener listener) { 11159 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagClose(this); 11160 } 11161 @Override 11162 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11163 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagClose(this); 11164 else return visitor.visitChildren(this); 11165 } 11166 } 11167 11168 public final TheadTagCloseContext theadTagClose() throws RecognitionException { 11169 TheadTagCloseContext _localctx = new TheadTagCloseContext(_ctx, getState()); 11170 enterRule(_localctx, 98, RULE_theadTagClose); 11171 int _la; 11172 try { 11173 enterOuterAlt(_localctx, 1); 11174 { 11175 setState(1285); 11176 match(OPEN); 11177 setState(1286); 11178 match(SLASH); 11179 setState(1287); 11180 match(THEAD_HTML_TAG_NAME); 11181 setState(1291); 11182 _errHandler.sync(this); 11183 _la = _input.LA(1); 11184 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 11185 { 11186 { 11187 setState(1288); 11188 _la = _input.LA(1); 11189 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 11190 _errHandler.recoverInline(this); 11191 } else { 11192 consume(); 11193 } 11194 } 11195 } 11196 setState(1293); 11197 _errHandler.sync(this); 11198 _la = _input.LA(1); 11199 } 11200 setState(1294); 11201 match(CLOSE); 11202 } 11203 } 11204 catch (RecognitionException re) { 11205 _localctx.exception = re; 11206 _errHandler.reportError(this, re); 11207 _errHandler.recover(this, re); 11208 } 11209 finally { 11210 exitRule(); 11211 } 11212 return _localctx; 11213 } 11214 11215 public static class TheadContext extends ParserRuleContext { 11216 public TheadTagOpenContext theadTagOpen() { 11217 return getRuleContext(TheadTagOpenContext.class,0); 11218 } 11219 public TheadTagCloseContext theadTagClose() { 11220 return getRuleContext(TheadTagCloseContext.class,0); 11221 } 11222 public List<HtmlTagContext> htmlTag() { 11223 return getRuleContexts(HtmlTagContext.class); 11224 } 11225 public HtmlTagContext htmlTag(int i) { 11226 return getRuleContext(HtmlTagContext.class,i); 11227 } 11228 public List<SingletonTagContext> singletonTag() { 11229 return getRuleContexts(SingletonTagContext.class); 11230 } 11231 public SingletonTagContext singletonTag(int i) { 11232 return getRuleContext(SingletonTagContext.class,i); 11233 } 11234 public List<ParagraphContext> paragraph() { 11235 return getRuleContexts(ParagraphContext.class); 11236 } 11237 public ParagraphContext paragraph(int i) { 11238 return getRuleContext(ParagraphContext.class,i); 11239 } 11240 public List<LiContext> li() { 11241 return getRuleContexts(LiContext.class); 11242 } 11243 public LiContext li(int i) { 11244 return getRuleContext(LiContext.class,i); 11245 } 11246 public List<TrContext> tr() { 11247 return getRuleContexts(TrContext.class); 11248 } 11249 public TrContext tr(int i) { 11250 return getRuleContext(TrContext.class,i); 11251 } 11252 public List<TdContext> td() { 11253 return getRuleContexts(TdContext.class); 11254 } 11255 public TdContext td(int i) { 11256 return getRuleContext(TdContext.class,i); 11257 } 11258 public List<ThContext> th() { 11259 return getRuleContexts(ThContext.class); 11260 } 11261 public ThContext th(int i) { 11262 return getRuleContext(ThContext.class,i); 11263 } 11264 public List<BodyContext> body() { 11265 return getRuleContexts(BodyContext.class); 11266 } 11267 public BodyContext body(int i) { 11268 return getRuleContext(BodyContext.class,i); 11269 } 11270 public List<ColgroupContext> colgroup() { 11271 return getRuleContexts(ColgroupContext.class); 11272 } 11273 public ColgroupContext colgroup(int i) { 11274 return getRuleContext(ColgroupContext.class,i); 11275 } 11276 public List<DdContext> dd() { 11277 return getRuleContexts(DdContext.class); 11278 } 11279 public DdContext dd(int i) { 11280 return getRuleContext(DdContext.class,i); 11281 } 11282 public List<DtContext> dt() { 11283 return getRuleContexts(DtContext.class); 11284 } 11285 public DtContext dt(int i) { 11286 return getRuleContext(DtContext.class,i); 11287 } 11288 public List<HeadContext> head() { 11289 return getRuleContexts(HeadContext.class); 11290 } 11291 public HeadContext head(int i) { 11292 return getRuleContext(HeadContext.class,i); 11293 } 11294 public List<HtmlContext> html() { 11295 return getRuleContexts(HtmlContext.class); 11296 } 11297 public HtmlContext html(int i) { 11298 return getRuleContext(HtmlContext.class,i); 11299 } 11300 public List<OptionContext> option() { 11301 return getRuleContexts(OptionContext.class); 11302 } 11303 public OptionContext option(int i) { 11304 return getRuleContext(OptionContext.class,i); 11305 } 11306 public List<TbodyContext> tbody() { 11307 return getRuleContexts(TbodyContext.class); 11308 } 11309 public TbodyContext tbody(int i) { 11310 return getRuleContext(TbodyContext.class,i); 11311 } 11312 public List<TfootContext> tfoot() { 11313 return getRuleContexts(TfootContext.class); 11314 } 11315 public TfootContext tfoot(int i) { 11316 return getRuleContext(TfootContext.class,i); 11317 } 11318 public List<PTagOpenContext> pTagOpen() { 11319 return getRuleContexts(PTagOpenContext.class); 11320 } 11321 public PTagOpenContext pTagOpen(int i) { 11322 return getRuleContext(PTagOpenContext.class,i); 11323 } 11324 public List<LiTagOpenContext> liTagOpen() { 11325 return getRuleContexts(LiTagOpenContext.class); 11326 } 11327 public LiTagOpenContext liTagOpen(int i) { 11328 return getRuleContext(LiTagOpenContext.class,i); 11329 } 11330 public List<TrTagOpenContext> trTagOpen() { 11331 return getRuleContexts(TrTagOpenContext.class); 11332 } 11333 public TrTagOpenContext trTagOpen(int i) { 11334 return getRuleContext(TrTagOpenContext.class,i); 11335 } 11336 public List<TdTagOpenContext> tdTagOpen() { 11337 return getRuleContexts(TdTagOpenContext.class); 11338 } 11339 public TdTagOpenContext tdTagOpen(int i) { 11340 return getRuleContext(TdTagOpenContext.class,i); 11341 } 11342 public List<ThTagOpenContext> thTagOpen() { 11343 return getRuleContexts(ThTagOpenContext.class); 11344 } 11345 public ThTagOpenContext thTagOpen(int i) { 11346 return getRuleContext(ThTagOpenContext.class,i); 11347 } 11348 public List<BodyTagOpenContext> bodyTagOpen() { 11349 return getRuleContexts(BodyTagOpenContext.class); 11350 } 11351 public BodyTagOpenContext bodyTagOpen(int i) { 11352 return getRuleContext(BodyTagOpenContext.class,i); 11353 } 11354 public List<ColgroupTagOpenContext> colgroupTagOpen() { 11355 return getRuleContexts(ColgroupTagOpenContext.class); 11356 } 11357 public ColgroupTagOpenContext colgroupTagOpen(int i) { 11358 return getRuleContext(ColgroupTagOpenContext.class,i); 11359 } 11360 public List<DdTagOpenContext> ddTagOpen() { 11361 return getRuleContexts(DdTagOpenContext.class); 11362 } 11363 public DdTagOpenContext ddTagOpen(int i) { 11364 return getRuleContext(DdTagOpenContext.class,i); 11365 } 11366 public List<DtTagOpenContext> dtTagOpen() { 11367 return getRuleContexts(DtTagOpenContext.class); 11368 } 11369 public DtTagOpenContext dtTagOpen(int i) { 11370 return getRuleContext(DtTagOpenContext.class,i); 11371 } 11372 public List<HeadTagOpenContext> headTagOpen() { 11373 return getRuleContexts(HeadTagOpenContext.class); 11374 } 11375 public HeadTagOpenContext headTagOpen(int i) { 11376 return getRuleContext(HeadTagOpenContext.class,i); 11377 } 11378 public List<HtmlTagOpenContext> htmlTagOpen() { 11379 return getRuleContexts(HtmlTagOpenContext.class); 11380 } 11381 public HtmlTagOpenContext htmlTagOpen(int i) { 11382 return getRuleContext(HtmlTagOpenContext.class,i); 11383 } 11384 public List<OptionTagOpenContext> optionTagOpen() { 11385 return getRuleContexts(OptionTagOpenContext.class); 11386 } 11387 public OptionTagOpenContext optionTagOpen(int i) { 11388 return getRuleContext(OptionTagOpenContext.class,i); 11389 } 11390 public List<TbodyTagOpenContext> tbodyTagOpen() { 11391 return getRuleContexts(TbodyTagOpenContext.class); 11392 } 11393 public TbodyTagOpenContext tbodyTagOpen(int i) { 11394 return getRuleContext(TbodyTagOpenContext.class,i); 11395 } 11396 public List<TfootTagOpenContext> tfootTagOpen() { 11397 return getRuleContexts(TfootTagOpenContext.class); 11398 } 11399 public TfootTagOpenContext tfootTagOpen(int i) { 11400 return getRuleContext(TfootTagOpenContext.class,i); 11401 } 11402 public List<HtmlCommentContext> htmlComment() { 11403 return getRuleContexts(HtmlCommentContext.class); 11404 } 11405 public HtmlCommentContext htmlComment(int i) { 11406 return getRuleContext(HtmlCommentContext.class,i); 11407 } 11408 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 11409 public TerminalNode CDATA(int i) { 11410 return getToken(JavadocParser.CDATA, i); 11411 } 11412 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11413 public TerminalNode NEWLINE(int i) { 11414 return getToken(JavadocParser.NEWLINE, i); 11415 } 11416 public List<TextContext> text() { 11417 return getRuleContexts(TextContext.class); 11418 } 11419 public TextContext text(int i) { 11420 return getRuleContext(TextContext.class,i); 11421 } 11422 public List<JavadocInlineTagContext> javadocInlineTag() { 11423 return getRuleContexts(JavadocInlineTagContext.class); 11424 } 11425 public JavadocInlineTagContext javadocInlineTag(int i) { 11426 return getRuleContext(JavadocInlineTagContext.class,i); 11427 } 11428 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11429 public TerminalNode LEADING_ASTERISK(int i) { 11430 return getToken(JavadocParser.LEADING_ASTERISK, i); 11431 } 11432 public TheadContext(ParserRuleContext parent, int invokingState) { 11433 super(parent, invokingState); 11434 } 11435 @Override public int getRuleIndex() { return RULE_thead; } 11436 @Override 11437 public void enterRule(ParseTreeListener listener) { 11438 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThead(this); 11439 } 11440 @Override 11441 public void exitRule(ParseTreeListener listener) { 11442 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThead(this); 11443 } 11444 @Override 11445 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11446 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThead(this); 11447 else return visitor.visitChildren(this); 11448 } 11449 } 11450 11451 public final TheadContext thead() throws RecognitionException { 11452 TheadContext _localctx = new TheadContext(_ctx, getState()); 11453 enterRule(_localctx, 100, RULE_thead); 11454 try { 11455 int _alt; 11456 enterOuterAlt(_localctx, 1); 11457 { 11458 setState(1296); 11459 theadTagOpen(); 11460 setState(1336); 11461 _errHandler.sync(this); 11462 _alt = getInterpreter().adaptivePredict(_input,91,_ctx); 11463 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 11464 if ( _alt==1 ) { 11465 { 11466 setState(1334); 11467 _errHandler.sync(this); 11468 switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) { 11469 case 1: 11470 { 11471 setState(1297); 11472 htmlTag(); 11473 } 11474 break; 11475 case 2: 11476 { 11477 setState(1298); 11478 singletonTag(); 11479 } 11480 break; 11481 case 3: 11482 { 11483 setState(1299); 11484 paragraph(); 11485 } 11486 break; 11487 case 4: 11488 { 11489 setState(1300); 11490 li(); 11491 } 11492 break; 11493 case 5: 11494 { 11495 setState(1301); 11496 tr(); 11497 } 11498 break; 11499 case 6: 11500 { 11501 setState(1302); 11502 td(); 11503 } 11504 break; 11505 case 7: 11506 { 11507 setState(1303); 11508 th(); 11509 } 11510 break; 11511 case 8: 11512 { 11513 setState(1304); 11514 body(); 11515 } 11516 break; 11517 case 9: 11518 { 11519 setState(1305); 11520 colgroup(); 11521 } 11522 break; 11523 case 10: 11524 { 11525 setState(1306); 11526 dd(); 11527 } 11528 break; 11529 case 11: 11530 { 11531 setState(1307); 11532 dt(); 11533 } 11534 break; 11535 case 12: 11536 { 11537 setState(1308); 11538 head(); 11539 } 11540 break; 11541 case 13: 11542 { 11543 setState(1309); 11544 html(); 11545 } 11546 break; 11547 case 14: 11548 { 11549 setState(1310); 11550 option(); 11551 } 11552 break; 11553 case 15: 11554 { 11555 setState(1311); 11556 tbody(); 11557 } 11558 break; 11559 case 16: 11560 { 11561 setState(1312); 11562 tfoot(); 11563 } 11564 break; 11565 case 17: 11566 { 11567 setState(1313); 11568 pTagOpen(); 11569 } 11570 break; 11571 case 18: 11572 { 11573 setState(1314); 11574 liTagOpen(); 11575 } 11576 break; 11577 case 19: 11578 { 11579 setState(1315); 11580 trTagOpen(); 11581 } 11582 break; 11583 case 20: 11584 { 11585 setState(1316); 11586 tdTagOpen(); 11587 } 11588 break; 11589 case 21: 11590 { 11591 setState(1317); 11592 thTagOpen(); 11593 } 11594 break; 11595 case 22: 11596 { 11597 setState(1318); 11598 bodyTagOpen(); 11599 } 11600 break; 11601 case 23: 11602 { 11603 setState(1319); 11604 colgroupTagOpen(); 11605 } 11606 break; 11607 case 24: 11608 { 11609 setState(1320); 11610 ddTagOpen(); 11611 } 11612 break; 11613 case 25: 11614 { 11615 setState(1321); 11616 dtTagOpen(); 11617 } 11618 break; 11619 case 26: 11620 { 11621 setState(1322); 11622 headTagOpen(); 11623 } 11624 break; 11625 case 27: 11626 { 11627 setState(1323); 11628 htmlTagOpen(); 11629 } 11630 break; 11631 case 28: 11632 { 11633 setState(1324); 11634 optionTagOpen(); 11635 } 11636 break; 11637 case 29: 11638 { 11639 setState(1325); 11640 tbodyTagOpen(); 11641 } 11642 break; 11643 case 30: 11644 { 11645 setState(1326); 11646 tfootTagOpen(); 11647 } 11648 break; 11649 case 31: 11650 { 11651 { 11652 setState(1327); 11653 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 11654 setState(1328); 11655 match(LEADING_ASTERISK); 11656 } 11657 } 11658 break; 11659 case 32: 11660 { 11661 setState(1329); 11662 htmlComment(); 11663 } 11664 break; 11665 case 33: 11666 { 11667 setState(1330); 11668 match(CDATA); 11669 } 11670 break; 11671 case 34: 11672 { 11673 setState(1331); 11674 match(NEWLINE); 11675 } 11676 break; 11677 case 35: 11678 { 11679 setState(1332); 11680 text(); 11681 } 11682 break; 11683 case 36: 11684 { 11685 setState(1333); 11686 javadocInlineTag(); 11687 } 11688 break; 11689 } 11690 } 11691 } 11692 setState(1338); 11693 _errHandler.sync(this); 11694 _alt = getInterpreter().adaptivePredict(_input,91,_ctx); 11695 } 11696 setState(1339); 11697 theadTagClose(); 11698 } 11699 } 11700 catch (RecognitionException re) { 11701 _localctx.exception = re; 11702 _errHandler.reportError(this, re); 11703 _errHandler.recover(this, re); 11704 } 11705 finally { 11706 exitRule(); 11707 } 11708 return _localctx; 11709 } 11710 11711 public static class SingletonElementContext extends ParserRuleContext { 11712 public SingletonTagContext singletonTag() { 11713 return getRuleContext(SingletonTagContext.class,0); 11714 } 11715 public AreaTagContext areaTag() { 11716 return getRuleContext(AreaTagContext.class,0); 11717 } 11718 public BaseTagContext baseTag() { 11719 return getRuleContext(BaseTagContext.class,0); 11720 } 11721 public BasefontTagContext basefontTag() { 11722 return getRuleContext(BasefontTagContext.class,0); 11723 } 11724 public BrTagContext brTag() { 11725 return getRuleContext(BrTagContext.class,0); 11726 } 11727 public ColTagContext colTag() { 11728 return getRuleContext(ColTagContext.class,0); 11729 } 11730 public FrameTagContext frameTag() { 11731 return getRuleContext(FrameTagContext.class,0); 11732 } 11733 public HrTagContext hrTag() { 11734 return getRuleContext(HrTagContext.class,0); 11735 } 11736 public ImgTagContext imgTag() { 11737 return getRuleContext(ImgTagContext.class,0); 11738 } 11739 public InputTagContext inputTag() { 11740 return getRuleContext(InputTagContext.class,0); 11741 } 11742 public IsindexTagContext isindexTag() { 11743 return getRuleContext(IsindexTagContext.class,0); 11744 } 11745 public LinkTagContext linkTag() { 11746 return getRuleContext(LinkTagContext.class,0); 11747 } 11748 public MetaTagContext metaTag() { 11749 return getRuleContext(MetaTagContext.class,0); 11750 } 11751 public ParamTagContext paramTag() { 11752 return getRuleContext(ParamTagContext.class,0); 11753 } 11754 public WrongSinletonTagContext wrongSinletonTag() { 11755 return getRuleContext(WrongSinletonTagContext.class,0); 11756 } 11757 public SingletonElementContext(ParserRuleContext parent, int invokingState) { 11758 super(parent, invokingState); 11759 } 11760 @Override public int getRuleIndex() { return RULE_singletonElement; } 11761 @Override 11762 public void enterRule(ParseTreeListener listener) { 11763 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonElement(this); 11764 } 11765 @Override 11766 public void exitRule(ParseTreeListener listener) { 11767 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonElement(this); 11768 } 11769 @Override 11770 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11771 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonElement(this); 11772 else return visitor.visitChildren(this); 11773 } 11774 } 11775 11776 public final SingletonElementContext singletonElement() throws RecognitionException { 11777 SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState()); 11778 enterRule(_localctx, 102, RULE_singletonElement); 11779 try { 11780 setState(1356); 11781 _errHandler.sync(this); 11782 switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) { 11783 case 1: 11784 enterOuterAlt(_localctx, 1); 11785 { 11786 setState(1341); 11787 singletonTag(); 11788 } 11789 break; 11790 case 2: 11791 enterOuterAlt(_localctx, 2); 11792 { 11793 setState(1342); 11794 areaTag(); 11795 } 11796 break; 11797 case 3: 11798 enterOuterAlt(_localctx, 3); 11799 { 11800 setState(1343); 11801 baseTag(); 11802 } 11803 break; 11804 case 4: 11805 enterOuterAlt(_localctx, 4); 11806 { 11807 setState(1344); 11808 basefontTag(); 11809 } 11810 break; 11811 case 5: 11812 enterOuterAlt(_localctx, 5); 11813 { 11814 setState(1345); 11815 brTag(); 11816 } 11817 break; 11818 case 6: 11819 enterOuterAlt(_localctx, 6); 11820 { 11821 setState(1346); 11822 colTag(); 11823 } 11824 break; 11825 case 7: 11826 enterOuterAlt(_localctx, 7); 11827 { 11828 setState(1347); 11829 frameTag(); 11830 } 11831 break; 11832 case 8: 11833 enterOuterAlt(_localctx, 8); 11834 { 11835 setState(1348); 11836 hrTag(); 11837 } 11838 break; 11839 case 9: 11840 enterOuterAlt(_localctx, 9); 11841 { 11842 setState(1349); 11843 imgTag(); 11844 } 11845 break; 11846 case 10: 11847 enterOuterAlt(_localctx, 10); 11848 { 11849 setState(1350); 11850 inputTag(); 11851 } 11852 break; 11853 case 11: 11854 enterOuterAlt(_localctx, 11); 11855 { 11856 setState(1351); 11857 isindexTag(); 11858 } 11859 break; 11860 case 12: 11861 enterOuterAlt(_localctx, 12); 11862 { 11863 setState(1352); 11864 linkTag(); 11865 } 11866 break; 11867 case 13: 11868 enterOuterAlt(_localctx, 13); 11869 { 11870 setState(1353); 11871 metaTag(); 11872 } 11873 break; 11874 case 14: 11875 enterOuterAlt(_localctx, 14); 11876 { 11877 setState(1354); 11878 paramTag(); 11879 } 11880 break; 11881 case 15: 11882 enterOuterAlt(_localctx, 15); 11883 { 11884 setState(1355); 11885 wrongSinletonTag(); 11886 } 11887 break; 11888 } 11889 } 11890 catch (RecognitionException re) { 11891 _localctx.exception = re; 11892 _errHandler.reportError(this, re); 11893 _errHandler.recover(this, re); 11894 } 11895 finally { 11896 exitRule(); 11897 } 11898 return _localctx; 11899 } 11900 11901 public static class SingletonTagContext extends ParserRuleContext { 11902 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11903 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 11904 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 11905 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 11906 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 11907 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 11908 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 11909 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 11910 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 11911 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 11912 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 11913 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 11914 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 11915 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 11916 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 11917 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 11918 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 11919 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11920 public List<AttributeContext> attribute() { 11921 return getRuleContexts(AttributeContext.class); 11922 } 11923 public AttributeContext attribute(int i) { 11924 return getRuleContext(AttributeContext.class,i); 11925 } 11926 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11927 public TerminalNode NEWLINE(int i) { 11928 return getToken(JavadocParser.NEWLINE, i); 11929 } 11930 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11931 public TerminalNode LEADING_ASTERISK(int i) { 11932 return getToken(JavadocParser.LEADING_ASTERISK, i); 11933 } 11934 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11935 public TerminalNode WS(int i) { 11936 return getToken(JavadocParser.WS, i); 11937 } 11938 public SingletonTagContext(ParserRuleContext parent, int invokingState) { 11939 super(parent, invokingState); 11940 } 11941 @Override public int getRuleIndex() { return RULE_singletonTag; } 11942 @Override 11943 public void enterRule(ParseTreeListener listener) { 11944 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTag(this); 11945 } 11946 @Override 11947 public void exitRule(ParseTreeListener listener) { 11948 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTag(this); 11949 } 11950 @Override 11951 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11952 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTag(this); 11953 else return visitor.visitChildren(this); 11954 } 11955 } 11956 11957 public final SingletonTagContext singletonTag() throws RecognitionException { 11958 SingletonTagContext _localctx = new SingletonTagContext(_ctx, getState()); 11959 enterRule(_localctx, 104, RULE_singletonTag); 11960 int _la; 11961 try { 11962 enterOuterAlt(_localctx, 1); 11963 { 11964 setState(1358); 11965 match(OPEN); 11966 setState(1359); 11967 _la = _input.LA(1); 11968 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)) ) { 11969 _errHandler.recoverInline(this); 11970 } else { 11971 consume(); 11972 } 11973 setState(1366); 11974 _errHandler.sync(this); 11975 _la = _input.LA(1); 11976 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11977 { 11978 setState(1364); 11979 switch (_input.LA(1)) { 11980 case HTML_TAG_NAME: 11981 { 11982 setState(1360); 11983 attribute(); 11984 } 11985 break; 11986 case NEWLINE: 11987 { 11988 setState(1361); 11989 match(NEWLINE); 11990 } 11991 break; 11992 case LEADING_ASTERISK: 11993 { 11994 setState(1362); 11995 match(LEADING_ASTERISK); 11996 } 11997 break; 11998 case WS: 11999 { 12000 setState(1363); 12001 match(WS); 12002 } 12003 break; 12004 default: 12005 throw new NoViableAltException(this); 12006 } 12007 } 12008 setState(1368); 12009 _errHandler.sync(this); 12010 _la = _input.LA(1); 12011 } 12012 setState(1369); 12013 match(SLASH_CLOSE); 12014 } 12015 } 12016 catch (RecognitionException re) { 12017 _localctx.exception = re; 12018 _errHandler.reportError(this, re); 12019 _errHandler.recover(this, re); 12020 } 12021 finally { 12022 exitRule(); 12023 } 12024 return _localctx; 12025 } 12026 12027 public static class AreaTagContext extends ParserRuleContext { 12028 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12029 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 12030 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12031 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12032 public List<AttributeContext> attribute() { 12033 return getRuleContexts(AttributeContext.class); 12034 } 12035 public AttributeContext attribute(int i) { 12036 return getRuleContext(AttributeContext.class,i); 12037 } 12038 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12039 public TerminalNode NEWLINE(int i) { 12040 return getToken(JavadocParser.NEWLINE, i); 12041 } 12042 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12043 public TerminalNode LEADING_ASTERISK(int i) { 12044 return getToken(JavadocParser.LEADING_ASTERISK, i); 12045 } 12046 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12047 public TerminalNode WS(int i) { 12048 return getToken(JavadocParser.WS, i); 12049 } 12050 public AreaTagContext(ParserRuleContext parent, int invokingState) { 12051 super(parent, invokingState); 12052 } 12053 @Override public int getRuleIndex() { return RULE_areaTag; } 12054 @Override 12055 public void enterRule(ParseTreeListener listener) { 12056 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAreaTag(this); 12057 } 12058 @Override 12059 public void exitRule(ParseTreeListener listener) { 12060 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAreaTag(this); 12061 } 12062 @Override 12063 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12064 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAreaTag(this); 12065 else return visitor.visitChildren(this); 12066 } 12067 } 12068 12069 public final AreaTagContext areaTag() throws RecognitionException { 12070 AreaTagContext _localctx = new AreaTagContext(_ctx, getState()); 12071 enterRule(_localctx, 106, RULE_areaTag); 12072 int _la; 12073 try { 12074 enterOuterAlt(_localctx, 1); 12075 { 12076 setState(1371); 12077 match(OPEN); 12078 setState(1372); 12079 match(AREA_HTML_TAG_NAME); 12080 setState(1379); 12081 _errHandler.sync(this); 12082 _la = _input.LA(1); 12083 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12084 { 12085 setState(1377); 12086 switch (_input.LA(1)) { 12087 case HTML_TAG_NAME: 12088 { 12089 setState(1373); 12090 attribute(); 12091 } 12092 break; 12093 case NEWLINE: 12094 { 12095 setState(1374); 12096 match(NEWLINE); 12097 } 12098 break; 12099 case LEADING_ASTERISK: 12100 { 12101 setState(1375); 12102 match(LEADING_ASTERISK); 12103 } 12104 break; 12105 case WS: 12106 { 12107 setState(1376); 12108 match(WS); 12109 } 12110 break; 12111 default: 12112 throw new NoViableAltException(this); 12113 } 12114 } 12115 setState(1381); 12116 _errHandler.sync(this); 12117 _la = _input.LA(1); 12118 } 12119 setState(1382); 12120 _la = _input.LA(1); 12121 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12122 _errHandler.recoverInline(this); 12123 } else { 12124 consume(); 12125 } 12126 } 12127 } 12128 catch (RecognitionException re) { 12129 _localctx.exception = re; 12130 _errHandler.reportError(this, re); 12131 _errHandler.recover(this, re); 12132 } 12133 finally { 12134 exitRule(); 12135 } 12136 return _localctx; 12137 } 12138 12139 public static class BaseTagContext extends ParserRuleContext { 12140 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12141 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 12142 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12143 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12144 public List<AttributeContext> attribute() { 12145 return getRuleContexts(AttributeContext.class); 12146 } 12147 public AttributeContext attribute(int i) { 12148 return getRuleContext(AttributeContext.class,i); 12149 } 12150 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12151 public TerminalNode NEWLINE(int i) { 12152 return getToken(JavadocParser.NEWLINE, i); 12153 } 12154 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12155 public TerminalNode LEADING_ASTERISK(int i) { 12156 return getToken(JavadocParser.LEADING_ASTERISK, i); 12157 } 12158 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12159 public TerminalNode WS(int i) { 12160 return getToken(JavadocParser.WS, i); 12161 } 12162 public BaseTagContext(ParserRuleContext parent, int invokingState) { 12163 super(parent, invokingState); 12164 } 12165 @Override public int getRuleIndex() { return RULE_baseTag; } 12166 @Override 12167 public void enterRule(ParseTreeListener listener) { 12168 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBaseTag(this); 12169 } 12170 @Override 12171 public void exitRule(ParseTreeListener listener) { 12172 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBaseTag(this); 12173 } 12174 @Override 12175 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12176 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBaseTag(this); 12177 else return visitor.visitChildren(this); 12178 } 12179 } 12180 12181 public final BaseTagContext baseTag() throws RecognitionException { 12182 BaseTagContext _localctx = new BaseTagContext(_ctx, getState()); 12183 enterRule(_localctx, 108, RULE_baseTag); 12184 int _la; 12185 try { 12186 enterOuterAlt(_localctx, 1); 12187 { 12188 setState(1384); 12189 match(OPEN); 12190 setState(1385); 12191 match(BASE_HTML_TAG_NAME); 12192 setState(1392); 12193 _errHandler.sync(this); 12194 _la = _input.LA(1); 12195 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12196 { 12197 setState(1390); 12198 switch (_input.LA(1)) { 12199 case HTML_TAG_NAME: 12200 { 12201 setState(1386); 12202 attribute(); 12203 } 12204 break; 12205 case NEWLINE: 12206 { 12207 setState(1387); 12208 match(NEWLINE); 12209 } 12210 break; 12211 case LEADING_ASTERISK: 12212 { 12213 setState(1388); 12214 match(LEADING_ASTERISK); 12215 } 12216 break; 12217 case WS: 12218 { 12219 setState(1389); 12220 match(WS); 12221 } 12222 break; 12223 default: 12224 throw new NoViableAltException(this); 12225 } 12226 } 12227 setState(1394); 12228 _errHandler.sync(this); 12229 _la = _input.LA(1); 12230 } 12231 setState(1395); 12232 _la = _input.LA(1); 12233 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12234 _errHandler.recoverInline(this); 12235 } else { 12236 consume(); 12237 } 12238 } 12239 } 12240 catch (RecognitionException re) { 12241 _localctx.exception = re; 12242 _errHandler.reportError(this, re); 12243 _errHandler.recover(this, re); 12244 } 12245 finally { 12246 exitRule(); 12247 } 12248 return _localctx; 12249 } 12250 12251 public static class BasefontTagContext extends ParserRuleContext { 12252 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12253 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 12254 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12255 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12256 public List<AttributeContext> attribute() { 12257 return getRuleContexts(AttributeContext.class); 12258 } 12259 public AttributeContext attribute(int i) { 12260 return getRuleContext(AttributeContext.class,i); 12261 } 12262 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12263 public TerminalNode NEWLINE(int i) { 12264 return getToken(JavadocParser.NEWLINE, i); 12265 } 12266 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12267 public TerminalNode LEADING_ASTERISK(int i) { 12268 return getToken(JavadocParser.LEADING_ASTERISK, i); 12269 } 12270 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12271 public TerminalNode WS(int i) { 12272 return getToken(JavadocParser.WS, i); 12273 } 12274 public BasefontTagContext(ParserRuleContext parent, int invokingState) { 12275 super(parent, invokingState); 12276 } 12277 @Override public int getRuleIndex() { return RULE_basefontTag; } 12278 @Override 12279 public void enterRule(ParseTreeListener listener) { 12280 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBasefontTag(this); 12281 } 12282 @Override 12283 public void exitRule(ParseTreeListener listener) { 12284 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBasefontTag(this); 12285 } 12286 @Override 12287 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12288 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBasefontTag(this); 12289 else return visitor.visitChildren(this); 12290 } 12291 } 12292 12293 public final BasefontTagContext basefontTag() throws RecognitionException { 12294 BasefontTagContext _localctx = new BasefontTagContext(_ctx, getState()); 12295 enterRule(_localctx, 110, RULE_basefontTag); 12296 int _la; 12297 try { 12298 enterOuterAlt(_localctx, 1); 12299 { 12300 setState(1397); 12301 match(OPEN); 12302 setState(1398); 12303 match(BASEFONT_HTML_TAG_NAME); 12304 setState(1405); 12305 _errHandler.sync(this); 12306 _la = _input.LA(1); 12307 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12308 { 12309 setState(1403); 12310 switch (_input.LA(1)) { 12311 case HTML_TAG_NAME: 12312 { 12313 setState(1399); 12314 attribute(); 12315 } 12316 break; 12317 case NEWLINE: 12318 { 12319 setState(1400); 12320 match(NEWLINE); 12321 } 12322 break; 12323 case LEADING_ASTERISK: 12324 { 12325 setState(1401); 12326 match(LEADING_ASTERISK); 12327 } 12328 break; 12329 case WS: 12330 { 12331 setState(1402); 12332 match(WS); 12333 } 12334 break; 12335 default: 12336 throw new NoViableAltException(this); 12337 } 12338 } 12339 setState(1407); 12340 _errHandler.sync(this); 12341 _la = _input.LA(1); 12342 } 12343 setState(1408); 12344 _la = _input.LA(1); 12345 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12346 _errHandler.recoverInline(this); 12347 } else { 12348 consume(); 12349 } 12350 } 12351 } 12352 catch (RecognitionException re) { 12353 _localctx.exception = re; 12354 _errHandler.reportError(this, re); 12355 _errHandler.recover(this, re); 12356 } 12357 finally { 12358 exitRule(); 12359 } 12360 return _localctx; 12361 } 12362 12363 public static class BrTagContext extends ParserRuleContext { 12364 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12365 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 12366 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12367 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12368 public List<AttributeContext> attribute() { 12369 return getRuleContexts(AttributeContext.class); 12370 } 12371 public AttributeContext attribute(int i) { 12372 return getRuleContext(AttributeContext.class,i); 12373 } 12374 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12375 public TerminalNode NEWLINE(int i) { 12376 return getToken(JavadocParser.NEWLINE, i); 12377 } 12378 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12379 public TerminalNode LEADING_ASTERISK(int i) { 12380 return getToken(JavadocParser.LEADING_ASTERISK, i); 12381 } 12382 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12383 public TerminalNode WS(int i) { 12384 return getToken(JavadocParser.WS, i); 12385 } 12386 public BrTagContext(ParserRuleContext parent, int invokingState) { 12387 super(parent, invokingState); 12388 } 12389 @Override public int getRuleIndex() { return RULE_brTag; } 12390 @Override 12391 public void enterRule(ParseTreeListener listener) { 12392 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBrTag(this); 12393 } 12394 @Override 12395 public void exitRule(ParseTreeListener listener) { 12396 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBrTag(this); 12397 } 12398 @Override 12399 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12400 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBrTag(this); 12401 else return visitor.visitChildren(this); 12402 } 12403 } 12404 12405 public final BrTagContext brTag() throws RecognitionException { 12406 BrTagContext _localctx = new BrTagContext(_ctx, getState()); 12407 enterRule(_localctx, 112, RULE_brTag); 12408 int _la; 12409 try { 12410 enterOuterAlt(_localctx, 1); 12411 { 12412 setState(1410); 12413 match(OPEN); 12414 setState(1411); 12415 match(BR_HTML_TAG_NAME); 12416 setState(1418); 12417 _errHandler.sync(this); 12418 _la = _input.LA(1); 12419 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12420 { 12421 setState(1416); 12422 switch (_input.LA(1)) { 12423 case HTML_TAG_NAME: 12424 { 12425 setState(1412); 12426 attribute(); 12427 } 12428 break; 12429 case NEWLINE: 12430 { 12431 setState(1413); 12432 match(NEWLINE); 12433 } 12434 break; 12435 case LEADING_ASTERISK: 12436 { 12437 setState(1414); 12438 match(LEADING_ASTERISK); 12439 } 12440 break; 12441 case WS: 12442 { 12443 setState(1415); 12444 match(WS); 12445 } 12446 break; 12447 default: 12448 throw new NoViableAltException(this); 12449 } 12450 } 12451 setState(1420); 12452 _errHandler.sync(this); 12453 _la = _input.LA(1); 12454 } 12455 setState(1421); 12456 _la = _input.LA(1); 12457 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12458 _errHandler.recoverInline(this); 12459 } else { 12460 consume(); 12461 } 12462 } 12463 } 12464 catch (RecognitionException re) { 12465 _localctx.exception = re; 12466 _errHandler.reportError(this, re); 12467 _errHandler.recover(this, re); 12468 } 12469 finally { 12470 exitRule(); 12471 } 12472 return _localctx; 12473 } 12474 12475 public static class ColTagContext extends ParserRuleContext { 12476 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12477 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 12478 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12479 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12480 public List<AttributeContext> attribute() { 12481 return getRuleContexts(AttributeContext.class); 12482 } 12483 public AttributeContext attribute(int i) { 12484 return getRuleContext(AttributeContext.class,i); 12485 } 12486 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12487 public TerminalNode NEWLINE(int i) { 12488 return getToken(JavadocParser.NEWLINE, i); 12489 } 12490 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12491 public TerminalNode LEADING_ASTERISK(int i) { 12492 return getToken(JavadocParser.LEADING_ASTERISK, i); 12493 } 12494 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12495 public TerminalNode WS(int i) { 12496 return getToken(JavadocParser.WS, i); 12497 } 12498 public ColTagContext(ParserRuleContext parent, int invokingState) { 12499 super(parent, invokingState); 12500 } 12501 @Override public int getRuleIndex() { return RULE_colTag; } 12502 @Override 12503 public void enterRule(ParseTreeListener listener) { 12504 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColTag(this); 12505 } 12506 @Override 12507 public void exitRule(ParseTreeListener listener) { 12508 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColTag(this); 12509 } 12510 @Override 12511 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12512 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColTag(this); 12513 else return visitor.visitChildren(this); 12514 } 12515 } 12516 12517 public final ColTagContext colTag() throws RecognitionException { 12518 ColTagContext _localctx = new ColTagContext(_ctx, getState()); 12519 enterRule(_localctx, 114, RULE_colTag); 12520 int _la; 12521 try { 12522 enterOuterAlt(_localctx, 1); 12523 { 12524 setState(1423); 12525 match(OPEN); 12526 setState(1424); 12527 match(COL_HTML_TAG_NAME); 12528 setState(1431); 12529 _errHandler.sync(this); 12530 _la = _input.LA(1); 12531 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12532 { 12533 setState(1429); 12534 switch (_input.LA(1)) { 12535 case HTML_TAG_NAME: 12536 { 12537 setState(1425); 12538 attribute(); 12539 } 12540 break; 12541 case NEWLINE: 12542 { 12543 setState(1426); 12544 match(NEWLINE); 12545 } 12546 break; 12547 case LEADING_ASTERISK: 12548 { 12549 setState(1427); 12550 match(LEADING_ASTERISK); 12551 } 12552 break; 12553 case WS: 12554 { 12555 setState(1428); 12556 match(WS); 12557 } 12558 break; 12559 default: 12560 throw new NoViableAltException(this); 12561 } 12562 } 12563 setState(1433); 12564 _errHandler.sync(this); 12565 _la = _input.LA(1); 12566 } 12567 setState(1434); 12568 _la = _input.LA(1); 12569 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12570 _errHandler.recoverInline(this); 12571 } else { 12572 consume(); 12573 } 12574 } 12575 } 12576 catch (RecognitionException re) { 12577 _localctx.exception = re; 12578 _errHandler.reportError(this, re); 12579 _errHandler.recover(this, re); 12580 } 12581 finally { 12582 exitRule(); 12583 } 12584 return _localctx; 12585 } 12586 12587 public static class FrameTagContext extends ParserRuleContext { 12588 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12589 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 12590 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12591 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12592 public List<AttributeContext> attribute() { 12593 return getRuleContexts(AttributeContext.class); 12594 } 12595 public AttributeContext attribute(int i) { 12596 return getRuleContext(AttributeContext.class,i); 12597 } 12598 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12599 public TerminalNode NEWLINE(int i) { 12600 return getToken(JavadocParser.NEWLINE, i); 12601 } 12602 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12603 public TerminalNode LEADING_ASTERISK(int i) { 12604 return getToken(JavadocParser.LEADING_ASTERISK, i); 12605 } 12606 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12607 public TerminalNode WS(int i) { 12608 return getToken(JavadocParser.WS, i); 12609 } 12610 public FrameTagContext(ParserRuleContext parent, int invokingState) { 12611 super(parent, invokingState); 12612 } 12613 @Override public int getRuleIndex() { return RULE_frameTag; } 12614 @Override 12615 public void enterRule(ParseTreeListener listener) { 12616 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterFrameTag(this); 12617 } 12618 @Override 12619 public void exitRule(ParseTreeListener listener) { 12620 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitFrameTag(this); 12621 } 12622 @Override 12623 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12624 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitFrameTag(this); 12625 else return visitor.visitChildren(this); 12626 } 12627 } 12628 12629 public final FrameTagContext frameTag() throws RecognitionException { 12630 FrameTagContext _localctx = new FrameTagContext(_ctx, getState()); 12631 enterRule(_localctx, 116, RULE_frameTag); 12632 int _la; 12633 try { 12634 enterOuterAlt(_localctx, 1); 12635 { 12636 setState(1436); 12637 match(OPEN); 12638 setState(1437); 12639 match(FRAME_HTML_TAG_NAME); 12640 setState(1444); 12641 _errHandler.sync(this); 12642 _la = _input.LA(1); 12643 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12644 { 12645 setState(1442); 12646 switch (_input.LA(1)) { 12647 case HTML_TAG_NAME: 12648 { 12649 setState(1438); 12650 attribute(); 12651 } 12652 break; 12653 case NEWLINE: 12654 { 12655 setState(1439); 12656 match(NEWLINE); 12657 } 12658 break; 12659 case LEADING_ASTERISK: 12660 { 12661 setState(1440); 12662 match(LEADING_ASTERISK); 12663 } 12664 break; 12665 case WS: 12666 { 12667 setState(1441); 12668 match(WS); 12669 } 12670 break; 12671 default: 12672 throw new NoViableAltException(this); 12673 } 12674 } 12675 setState(1446); 12676 _errHandler.sync(this); 12677 _la = _input.LA(1); 12678 } 12679 setState(1447); 12680 _la = _input.LA(1); 12681 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12682 _errHandler.recoverInline(this); 12683 } else { 12684 consume(); 12685 } 12686 } 12687 } 12688 catch (RecognitionException re) { 12689 _localctx.exception = re; 12690 _errHandler.reportError(this, re); 12691 _errHandler.recover(this, re); 12692 } 12693 finally { 12694 exitRule(); 12695 } 12696 return _localctx; 12697 } 12698 12699 public static class HrTagContext extends ParserRuleContext { 12700 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12701 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 12702 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12703 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12704 public List<AttributeContext> attribute() { 12705 return getRuleContexts(AttributeContext.class); 12706 } 12707 public AttributeContext attribute(int i) { 12708 return getRuleContext(AttributeContext.class,i); 12709 } 12710 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12711 public TerminalNode NEWLINE(int i) { 12712 return getToken(JavadocParser.NEWLINE, i); 12713 } 12714 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12715 public TerminalNode LEADING_ASTERISK(int i) { 12716 return getToken(JavadocParser.LEADING_ASTERISK, i); 12717 } 12718 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12719 public TerminalNode WS(int i) { 12720 return getToken(JavadocParser.WS, i); 12721 } 12722 public HrTagContext(ParserRuleContext parent, int invokingState) { 12723 super(parent, invokingState); 12724 } 12725 @Override public int getRuleIndex() { return RULE_hrTag; } 12726 @Override 12727 public void enterRule(ParseTreeListener listener) { 12728 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHrTag(this); 12729 } 12730 @Override 12731 public void exitRule(ParseTreeListener listener) { 12732 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHrTag(this); 12733 } 12734 @Override 12735 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12736 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHrTag(this); 12737 else return visitor.visitChildren(this); 12738 } 12739 } 12740 12741 public final HrTagContext hrTag() throws RecognitionException { 12742 HrTagContext _localctx = new HrTagContext(_ctx, getState()); 12743 enterRule(_localctx, 118, RULE_hrTag); 12744 int _la; 12745 try { 12746 enterOuterAlt(_localctx, 1); 12747 { 12748 setState(1449); 12749 match(OPEN); 12750 setState(1450); 12751 match(HR_HTML_TAG_NAME); 12752 setState(1457); 12753 _errHandler.sync(this); 12754 _la = _input.LA(1); 12755 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12756 { 12757 setState(1455); 12758 switch (_input.LA(1)) { 12759 case HTML_TAG_NAME: 12760 { 12761 setState(1451); 12762 attribute(); 12763 } 12764 break; 12765 case NEWLINE: 12766 { 12767 setState(1452); 12768 match(NEWLINE); 12769 } 12770 break; 12771 case LEADING_ASTERISK: 12772 { 12773 setState(1453); 12774 match(LEADING_ASTERISK); 12775 } 12776 break; 12777 case WS: 12778 { 12779 setState(1454); 12780 match(WS); 12781 } 12782 break; 12783 default: 12784 throw new NoViableAltException(this); 12785 } 12786 } 12787 setState(1459); 12788 _errHandler.sync(this); 12789 _la = _input.LA(1); 12790 } 12791 setState(1460); 12792 _la = _input.LA(1); 12793 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12794 _errHandler.recoverInline(this); 12795 } else { 12796 consume(); 12797 } 12798 } 12799 } 12800 catch (RecognitionException re) { 12801 _localctx.exception = re; 12802 _errHandler.reportError(this, re); 12803 _errHandler.recover(this, re); 12804 } 12805 finally { 12806 exitRule(); 12807 } 12808 return _localctx; 12809 } 12810 12811 public static class ImgTagContext extends ParserRuleContext { 12812 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12813 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 12814 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12815 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12816 public List<AttributeContext> attribute() { 12817 return getRuleContexts(AttributeContext.class); 12818 } 12819 public AttributeContext attribute(int i) { 12820 return getRuleContext(AttributeContext.class,i); 12821 } 12822 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12823 public TerminalNode NEWLINE(int i) { 12824 return getToken(JavadocParser.NEWLINE, i); 12825 } 12826 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12827 public TerminalNode LEADING_ASTERISK(int i) { 12828 return getToken(JavadocParser.LEADING_ASTERISK, i); 12829 } 12830 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12831 public TerminalNode WS(int i) { 12832 return getToken(JavadocParser.WS, i); 12833 } 12834 public ImgTagContext(ParserRuleContext parent, int invokingState) { 12835 super(parent, invokingState); 12836 } 12837 @Override public int getRuleIndex() { return RULE_imgTag; } 12838 @Override 12839 public void enterRule(ParseTreeListener listener) { 12840 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterImgTag(this); 12841 } 12842 @Override 12843 public void exitRule(ParseTreeListener listener) { 12844 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitImgTag(this); 12845 } 12846 @Override 12847 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12848 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitImgTag(this); 12849 else return visitor.visitChildren(this); 12850 } 12851 } 12852 12853 public final ImgTagContext imgTag() throws RecognitionException { 12854 ImgTagContext _localctx = new ImgTagContext(_ctx, getState()); 12855 enterRule(_localctx, 120, RULE_imgTag); 12856 int _la; 12857 try { 12858 enterOuterAlt(_localctx, 1); 12859 { 12860 setState(1462); 12861 match(OPEN); 12862 setState(1463); 12863 match(IMG_HTML_TAG_NAME); 12864 setState(1470); 12865 _errHandler.sync(this); 12866 _la = _input.LA(1); 12867 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12868 { 12869 setState(1468); 12870 switch (_input.LA(1)) { 12871 case HTML_TAG_NAME: 12872 { 12873 setState(1464); 12874 attribute(); 12875 } 12876 break; 12877 case NEWLINE: 12878 { 12879 setState(1465); 12880 match(NEWLINE); 12881 } 12882 break; 12883 case LEADING_ASTERISK: 12884 { 12885 setState(1466); 12886 match(LEADING_ASTERISK); 12887 } 12888 break; 12889 case WS: 12890 { 12891 setState(1467); 12892 match(WS); 12893 } 12894 break; 12895 default: 12896 throw new NoViableAltException(this); 12897 } 12898 } 12899 setState(1472); 12900 _errHandler.sync(this); 12901 _la = _input.LA(1); 12902 } 12903 setState(1473); 12904 _la = _input.LA(1); 12905 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12906 _errHandler.recoverInline(this); 12907 } else { 12908 consume(); 12909 } 12910 } 12911 } 12912 catch (RecognitionException re) { 12913 _localctx.exception = re; 12914 _errHandler.reportError(this, re); 12915 _errHandler.recover(this, re); 12916 } 12917 finally { 12918 exitRule(); 12919 } 12920 return _localctx; 12921 } 12922 12923 public static class InputTagContext extends ParserRuleContext { 12924 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12925 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 12926 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12927 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12928 public List<AttributeContext> attribute() { 12929 return getRuleContexts(AttributeContext.class); 12930 } 12931 public AttributeContext attribute(int i) { 12932 return getRuleContext(AttributeContext.class,i); 12933 } 12934 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12935 public TerminalNode NEWLINE(int i) { 12936 return getToken(JavadocParser.NEWLINE, i); 12937 } 12938 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12939 public TerminalNode LEADING_ASTERISK(int i) { 12940 return getToken(JavadocParser.LEADING_ASTERISK, i); 12941 } 12942 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12943 public TerminalNode WS(int i) { 12944 return getToken(JavadocParser.WS, i); 12945 } 12946 public InputTagContext(ParserRuleContext parent, int invokingState) { 12947 super(parent, invokingState); 12948 } 12949 @Override public int getRuleIndex() { return RULE_inputTag; } 12950 @Override 12951 public void enterRule(ParseTreeListener listener) { 12952 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInputTag(this); 12953 } 12954 @Override 12955 public void exitRule(ParseTreeListener listener) { 12956 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInputTag(this); 12957 } 12958 @Override 12959 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12960 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInputTag(this); 12961 else return visitor.visitChildren(this); 12962 } 12963 } 12964 12965 public final InputTagContext inputTag() throws RecognitionException { 12966 InputTagContext _localctx = new InputTagContext(_ctx, getState()); 12967 enterRule(_localctx, 122, RULE_inputTag); 12968 int _la; 12969 try { 12970 enterOuterAlt(_localctx, 1); 12971 { 12972 setState(1475); 12973 match(OPEN); 12974 setState(1476); 12975 match(INPUT_HTML_TAG_NAME); 12976 setState(1483); 12977 _errHandler.sync(this); 12978 _la = _input.LA(1); 12979 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12980 { 12981 setState(1481); 12982 switch (_input.LA(1)) { 12983 case HTML_TAG_NAME: 12984 { 12985 setState(1477); 12986 attribute(); 12987 } 12988 break; 12989 case NEWLINE: 12990 { 12991 setState(1478); 12992 match(NEWLINE); 12993 } 12994 break; 12995 case LEADING_ASTERISK: 12996 { 12997 setState(1479); 12998 match(LEADING_ASTERISK); 12999 } 13000 break; 13001 case WS: 13002 { 13003 setState(1480); 13004 match(WS); 13005 } 13006 break; 13007 default: 13008 throw new NoViableAltException(this); 13009 } 13010 } 13011 setState(1485); 13012 _errHandler.sync(this); 13013 _la = _input.LA(1); 13014 } 13015 setState(1486); 13016 _la = _input.LA(1); 13017 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13018 _errHandler.recoverInline(this); 13019 } else { 13020 consume(); 13021 } 13022 } 13023 } 13024 catch (RecognitionException re) { 13025 _localctx.exception = re; 13026 _errHandler.reportError(this, re); 13027 _errHandler.recover(this, re); 13028 } 13029 finally { 13030 exitRule(); 13031 } 13032 return _localctx; 13033 } 13034 13035 public static class IsindexTagContext extends ParserRuleContext { 13036 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13037 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 13038 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13039 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13040 public List<AttributeContext> attribute() { 13041 return getRuleContexts(AttributeContext.class); 13042 } 13043 public AttributeContext attribute(int i) { 13044 return getRuleContext(AttributeContext.class,i); 13045 } 13046 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13047 public TerminalNode NEWLINE(int i) { 13048 return getToken(JavadocParser.NEWLINE, i); 13049 } 13050 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13051 public TerminalNode LEADING_ASTERISK(int i) { 13052 return getToken(JavadocParser.LEADING_ASTERISK, i); 13053 } 13054 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13055 public TerminalNode WS(int i) { 13056 return getToken(JavadocParser.WS, i); 13057 } 13058 public IsindexTagContext(ParserRuleContext parent, int invokingState) { 13059 super(parent, invokingState); 13060 } 13061 @Override public int getRuleIndex() { return RULE_isindexTag; } 13062 @Override 13063 public void enterRule(ParseTreeListener listener) { 13064 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterIsindexTag(this); 13065 } 13066 @Override 13067 public void exitRule(ParseTreeListener listener) { 13068 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitIsindexTag(this); 13069 } 13070 @Override 13071 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13072 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitIsindexTag(this); 13073 else return visitor.visitChildren(this); 13074 } 13075 } 13076 13077 public final IsindexTagContext isindexTag() throws RecognitionException { 13078 IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState()); 13079 enterRule(_localctx, 124, RULE_isindexTag); 13080 int _la; 13081 try { 13082 enterOuterAlt(_localctx, 1); 13083 { 13084 setState(1488); 13085 match(OPEN); 13086 setState(1489); 13087 match(ISINDEX_HTML_TAG_NAME); 13088 setState(1496); 13089 _errHandler.sync(this); 13090 _la = _input.LA(1); 13091 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13092 { 13093 setState(1494); 13094 switch (_input.LA(1)) { 13095 case HTML_TAG_NAME: 13096 { 13097 setState(1490); 13098 attribute(); 13099 } 13100 break; 13101 case NEWLINE: 13102 { 13103 setState(1491); 13104 match(NEWLINE); 13105 } 13106 break; 13107 case LEADING_ASTERISK: 13108 { 13109 setState(1492); 13110 match(LEADING_ASTERISK); 13111 } 13112 break; 13113 case WS: 13114 { 13115 setState(1493); 13116 match(WS); 13117 } 13118 break; 13119 default: 13120 throw new NoViableAltException(this); 13121 } 13122 } 13123 setState(1498); 13124 _errHandler.sync(this); 13125 _la = _input.LA(1); 13126 } 13127 setState(1499); 13128 _la = _input.LA(1); 13129 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13130 _errHandler.recoverInline(this); 13131 } else { 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 LinkTagContext extends ParserRuleContext { 13148 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13149 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_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 LinkTagContext(ParserRuleContext parent, int invokingState) { 13171 super(parent, invokingState); 13172 } 13173 @Override public int getRuleIndex() { return RULE_linkTag; } 13174 @Override 13175 public void enterRule(ParseTreeListener listener) { 13176 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLinkTag(this); 13177 } 13178 @Override 13179 public void exitRule(ParseTreeListener listener) { 13180 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLinkTag(this); 13181 } 13182 @Override 13183 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13184 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLinkTag(this); 13185 else return visitor.visitChildren(this); 13186 } 13187 } 13188 13189 public final LinkTagContext linkTag() throws RecognitionException { 13190 LinkTagContext _localctx = new LinkTagContext(_ctx, getState()); 13191 enterRule(_localctx, 126, RULE_linkTag); 13192 int _la; 13193 try { 13194 enterOuterAlt(_localctx, 1); 13195 { 13196 setState(1501); 13197 match(OPEN); 13198 setState(1502); 13199 match(LINK_HTML_TAG_NAME); 13200 setState(1509); 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(1507); 13206 switch (_input.LA(1)) { 13207 case HTML_TAG_NAME: 13208 { 13209 setState(1503); 13210 attribute(); 13211 } 13212 break; 13213 case NEWLINE: 13214 { 13215 setState(1504); 13216 match(NEWLINE); 13217 } 13218 break; 13219 case LEADING_ASTERISK: 13220 { 13221 setState(1505); 13222 match(LEADING_ASTERISK); 13223 } 13224 break; 13225 case WS: 13226 { 13227 setState(1506); 13228 match(WS); 13229 } 13230 break; 13231 default: 13232 throw new NoViableAltException(this); 13233 } 13234 } 13235 setState(1511); 13236 _errHandler.sync(this); 13237 _la = _input.LA(1); 13238 } 13239 setState(1512); 13240 _la = _input.LA(1); 13241 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13242 _errHandler.recoverInline(this); 13243 } else { 13244 consume(); 13245 } 13246 } 13247 } 13248 catch (RecognitionException re) { 13249 _localctx.exception = re; 13250 _errHandler.reportError(this, re); 13251 _errHandler.recover(this, re); 13252 } 13253 finally { 13254 exitRule(); 13255 } 13256 return _localctx; 13257 } 13258 13259 public static class MetaTagContext extends ParserRuleContext { 13260 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13261 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 13262 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13263 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13264 public List<AttributeContext> attribute() { 13265 return getRuleContexts(AttributeContext.class); 13266 } 13267 public AttributeContext attribute(int i) { 13268 return getRuleContext(AttributeContext.class,i); 13269 } 13270 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13271 public TerminalNode NEWLINE(int i) { 13272 return getToken(JavadocParser.NEWLINE, i); 13273 } 13274 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13275 public TerminalNode LEADING_ASTERISK(int i) { 13276 return getToken(JavadocParser.LEADING_ASTERISK, i); 13277 } 13278 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13279 public TerminalNode WS(int i) { 13280 return getToken(JavadocParser.WS, i); 13281 } 13282 public MetaTagContext(ParserRuleContext parent, int invokingState) { 13283 super(parent, invokingState); 13284 } 13285 @Override public int getRuleIndex() { return RULE_metaTag; } 13286 @Override 13287 public void enterRule(ParseTreeListener listener) { 13288 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterMetaTag(this); 13289 } 13290 @Override 13291 public void exitRule(ParseTreeListener listener) { 13292 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitMetaTag(this); 13293 } 13294 @Override 13295 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13296 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitMetaTag(this); 13297 else return visitor.visitChildren(this); 13298 } 13299 } 13300 13301 public final MetaTagContext metaTag() throws RecognitionException { 13302 MetaTagContext _localctx = new MetaTagContext(_ctx, getState()); 13303 enterRule(_localctx, 128, RULE_metaTag); 13304 int _la; 13305 try { 13306 enterOuterAlt(_localctx, 1); 13307 { 13308 setState(1514); 13309 match(OPEN); 13310 setState(1515); 13311 match(META_HTML_TAG_NAME); 13312 setState(1522); 13313 _errHandler.sync(this); 13314 _la = _input.LA(1); 13315 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13316 { 13317 setState(1520); 13318 switch (_input.LA(1)) { 13319 case HTML_TAG_NAME: 13320 { 13321 setState(1516); 13322 attribute(); 13323 } 13324 break; 13325 case NEWLINE: 13326 { 13327 setState(1517); 13328 match(NEWLINE); 13329 } 13330 break; 13331 case LEADING_ASTERISK: 13332 { 13333 setState(1518); 13334 match(LEADING_ASTERISK); 13335 } 13336 break; 13337 case WS: 13338 { 13339 setState(1519); 13340 match(WS); 13341 } 13342 break; 13343 default: 13344 throw new NoViableAltException(this); 13345 } 13346 } 13347 setState(1524); 13348 _errHandler.sync(this); 13349 _la = _input.LA(1); 13350 } 13351 setState(1525); 13352 _la = _input.LA(1); 13353 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13354 _errHandler.recoverInline(this); 13355 } else { 13356 consume(); 13357 } 13358 } 13359 } 13360 catch (RecognitionException re) { 13361 _localctx.exception = re; 13362 _errHandler.reportError(this, re); 13363 _errHandler.recover(this, re); 13364 } 13365 finally { 13366 exitRule(); 13367 } 13368 return _localctx; 13369 } 13370 13371 public static class ParamTagContext extends ParserRuleContext { 13372 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13373 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 13374 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13375 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13376 public List<AttributeContext> attribute() { 13377 return getRuleContexts(AttributeContext.class); 13378 } 13379 public AttributeContext attribute(int i) { 13380 return getRuleContext(AttributeContext.class,i); 13381 } 13382 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13383 public TerminalNode NEWLINE(int i) { 13384 return getToken(JavadocParser.NEWLINE, i); 13385 } 13386 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13387 public TerminalNode LEADING_ASTERISK(int i) { 13388 return getToken(JavadocParser.LEADING_ASTERISK, i); 13389 } 13390 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13391 public TerminalNode WS(int i) { 13392 return getToken(JavadocParser.WS, i); 13393 } 13394 public ParamTagContext(ParserRuleContext parent, int invokingState) { 13395 super(parent, invokingState); 13396 } 13397 @Override public int getRuleIndex() { return RULE_paramTag; } 13398 @Override 13399 public void enterRule(ParseTreeListener listener) { 13400 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParamTag(this); 13401 } 13402 @Override 13403 public void exitRule(ParseTreeListener listener) { 13404 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParamTag(this); 13405 } 13406 @Override 13407 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13408 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParamTag(this); 13409 else return visitor.visitChildren(this); 13410 } 13411 } 13412 13413 public final ParamTagContext paramTag() throws RecognitionException { 13414 ParamTagContext _localctx = new ParamTagContext(_ctx, getState()); 13415 enterRule(_localctx, 130, RULE_paramTag); 13416 int _la; 13417 try { 13418 enterOuterAlt(_localctx, 1); 13419 { 13420 setState(1527); 13421 match(OPEN); 13422 setState(1528); 13423 match(PARAM_HTML_TAG_NAME); 13424 setState(1535); 13425 _errHandler.sync(this); 13426 _la = _input.LA(1); 13427 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13428 { 13429 setState(1533); 13430 switch (_input.LA(1)) { 13431 case HTML_TAG_NAME: 13432 { 13433 setState(1529); 13434 attribute(); 13435 } 13436 break; 13437 case NEWLINE: 13438 { 13439 setState(1530); 13440 match(NEWLINE); 13441 } 13442 break; 13443 case LEADING_ASTERISK: 13444 { 13445 setState(1531); 13446 match(LEADING_ASTERISK); 13447 } 13448 break; 13449 case WS: 13450 { 13451 setState(1532); 13452 match(WS); 13453 } 13454 break; 13455 default: 13456 throw new NoViableAltException(this); 13457 } 13458 } 13459 setState(1537); 13460 _errHandler.sync(this); 13461 _la = _input.LA(1); 13462 } 13463 setState(1538); 13464 _la = _input.LA(1); 13465 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13466 _errHandler.recoverInline(this); 13467 } else { 13468 consume(); 13469 } 13470 } 13471 } 13472 catch (RecognitionException re) { 13473 _localctx.exception = re; 13474 _errHandler.reportError(this, re); 13475 _errHandler.recover(this, re); 13476 } 13477 finally { 13478 exitRule(); 13479 } 13480 return _localctx; 13481 } 13482 13483 public static class WrongSinletonTagContext extends ParserRuleContext { 13484 public SingletonTagNameContext singletonTagName; 13485 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13486 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 13487 public SingletonTagNameContext singletonTagName() { 13488 return getRuleContext(SingletonTagNameContext.class,0); 13489 } 13490 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13491 public WrongSinletonTagContext(ParserRuleContext parent, int invokingState) { 13492 super(parent, invokingState); 13493 } 13494 @Override public int getRuleIndex() { return RULE_wrongSinletonTag; } 13495 @Override 13496 public void enterRule(ParseTreeListener listener) { 13497 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterWrongSinletonTag(this); 13498 } 13499 @Override 13500 public void exitRule(ParseTreeListener listener) { 13501 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitWrongSinletonTag(this); 13502 } 13503 @Override 13504 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13505 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWrongSinletonTag(this); 13506 else return visitor.visitChildren(this); 13507 } 13508 } 13509 13510 public final WrongSinletonTagContext wrongSinletonTag() throws RecognitionException { 13511 WrongSinletonTagContext _localctx = new WrongSinletonTagContext(_ctx, getState()); 13512 enterRule(_localctx, 132, RULE_wrongSinletonTag); 13513 try { 13514 enterOuterAlt(_localctx, 1); 13515 { 13516 setState(1540); 13517 match(OPEN); 13518 setState(1541); 13519 match(SLASH); 13520 setState(1542); 13521 ((WrongSinletonTagContext)_localctx).singletonTagName = singletonTagName(); 13522 setState(1543); 13523 match(CLOSE); 13524 notifyErrorListeners((((WrongSinletonTagContext)_localctx).singletonTagName!=null?(((WrongSinletonTagContext)_localctx).singletonTagName.start):null), 13525 "javadoc.wrong.singleton.html.tag", null); 13526 } 13527 } 13528 catch (RecognitionException re) { 13529 _localctx.exception = re; 13530 _errHandler.reportError(this, re); 13531 _errHandler.recover(this, re); 13532 } 13533 finally { 13534 exitRule(); 13535 } 13536 return _localctx; 13537 } 13538 13539 public static class SingletonTagNameContext extends ParserRuleContext { 13540 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 13541 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 13542 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 13543 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 13544 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 13545 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 13546 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 13547 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 13548 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 13549 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 13550 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 13551 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 13552 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 13553 public SingletonTagNameContext(ParserRuleContext parent, int invokingState) { 13554 super(parent, invokingState); 13555 } 13556 @Override public int getRuleIndex() { return RULE_singletonTagName; } 13557 @Override 13558 public void enterRule(ParseTreeListener listener) { 13559 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTagName(this); 13560 } 13561 @Override 13562 public void exitRule(ParseTreeListener listener) { 13563 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTagName(this); 13564 } 13565 @Override 13566 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13567 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTagName(this); 13568 else return visitor.visitChildren(this); 13569 } 13570 } 13571 13572 public final SingletonTagNameContext singletonTagName() throws RecognitionException { 13573 SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState()); 13574 enterRule(_localctx, 134, RULE_singletonTagName); 13575 int _la; 13576 try { 13577 enterOuterAlt(_localctx, 1); 13578 { 13579 setState(1546); 13580 _la = _input.LA(1); 13581 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)) ) { 13582 _errHandler.recoverInline(this); 13583 } else { 13584 consume(); 13585 } 13586 } 13587 } 13588 catch (RecognitionException re) { 13589 _localctx.exception = re; 13590 _errHandler.reportError(this, re); 13591 _errHandler.recover(this, re); 13592 } 13593 finally { 13594 exitRule(); 13595 } 13596 return _localctx; 13597 } 13598 13599 public static class DescriptionContext extends ParserRuleContext { 13600 public List<HtmlCommentContext> htmlComment() { 13601 return getRuleContexts(HtmlCommentContext.class); 13602 } 13603 public HtmlCommentContext htmlComment(int i) { 13604 return getRuleContext(HtmlCommentContext.class,i); 13605 } 13606 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 13607 public TerminalNode CDATA(int i) { 13608 return getToken(JavadocParser.CDATA, i); 13609 } 13610 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13611 public TerminalNode NEWLINE(int i) { 13612 return getToken(JavadocParser.NEWLINE, i); 13613 } 13614 public List<TextContext> text() { 13615 return getRuleContexts(TextContext.class); 13616 } 13617 public TextContext text(int i) { 13618 return getRuleContext(TextContext.class,i); 13619 } 13620 public List<JavadocInlineTagContext> javadocInlineTag() { 13621 return getRuleContexts(JavadocInlineTagContext.class); 13622 } 13623 public JavadocInlineTagContext javadocInlineTag(int i) { 13624 return getRuleContext(JavadocInlineTagContext.class,i); 13625 } 13626 public List<HtmlElementContext> htmlElement() { 13627 return getRuleContexts(HtmlElementContext.class); 13628 } 13629 public HtmlElementContext htmlElement(int i) { 13630 return getRuleContext(HtmlElementContext.class,i); 13631 } 13632 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13633 public TerminalNode LEADING_ASTERISK(int i) { 13634 return getToken(JavadocParser.LEADING_ASTERISK, i); 13635 } 13636 public DescriptionContext(ParserRuleContext parent, int invokingState) { 13637 super(parent, invokingState); 13638 } 13639 @Override public int getRuleIndex() { return RULE_description; } 13640 @Override 13641 public void enterRule(ParseTreeListener listener) { 13642 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescription(this); 13643 } 13644 @Override 13645 public void exitRule(ParseTreeListener listener) { 13646 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescription(this); 13647 } 13648 @Override 13649 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13650 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this); 13651 else return visitor.visitChildren(this); 13652 } 13653 } 13654 13655 public final DescriptionContext description() throws RecognitionException { 13656 DescriptionContext _localctx = new DescriptionContext(_ctx, getState()); 13657 enterRule(_localctx, 136, RULE_description); 13658 try { 13659 int _alt; 13660 enterOuterAlt(_localctx, 1); 13661 { 13662 setState(1556); 13663 _errHandler.sync(this); 13664 _alt = 1; 13665 do { 13666 switch (_alt) { 13667 case 1: 13668 { 13669 setState(1556); 13670 _errHandler.sync(this); 13671 switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) { 13672 case 1: 13673 { 13674 { 13675 setState(1548); 13676 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 13677 setState(1549); 13678 match(LEADING_ASTERISK); 13679 } 13680 } 13681 break; 13682 case 2: 13683 { 13684 setState(1550); 13685 htmlComment(); 13686 } 13687 break; 13688 case 3: 13689 { 13690 setState(1551); 13691 match(CDATA); 13692 } 13693 break; 13694 case 4: 13695 { 13696 setState(1552); 13697 match(NEWLINE); 13698 } 13699 break; 13700 case 5: 13701 { 13702 setState(1553); 13703 text(); 13704 } 13705 break; 13706 case 6: 13707 { 13708 setState(1554); 13709 javadocInlineTag(); 13710 } 13711 break; 13712 case 7: 13713 { 13714 setState(1555); 13715 htmlElement(); 13716 } 13717 break; 13718 } 13719 } 13720 break; 13721 default: 13722 throw new NoViableAltException(this); 13723 } 13724 setState(1558); 13725 _errHandler.sync(this); 13726 _alt = getInterpreter().adaptivePredict(_input,122,_ctx); 13727 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13728 } 13729 } 13730 catch (RecognitionException re) { 13731 _localctx.exception = re; 13732 _errHandler.reportError(this, re); 13733 _errHandler.recover(this, re); 13734 } 13735 finally { 13736 exitRule(); 13737 } 13738 return _localctx; 13739 } 13740 13741 public static class ReferenceContext extends ParserRuleContext { 13742 public TerminalNode PACKAGE() { return getToken(JavadocParser.PACKAGE, 0); } 13743 public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); } 13744 public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); } 13745 public ParametersContext parameters() { 13746 return getRuleContext(ParametersContext.class,0); 13747 } 13748 public List<TerminalNode> DOT() { return getTokens(JavadocParser.DOT); } 13749 public TerminalNode DOT(int i) { 13750 return getToken(JavadocParser.DOT, i); 13751 } 13752 public List<TerminalNode> CLASS() { return getTokens(JavadocParser.CLASS); } 13753 public TerminalNode CLASS(int i) { 13754 return getToken(JavadocParser.CLASS, i); 13755 } 13756 public ReferenceContext(ParserRuleContext parent, int invokingState) { 13757 super(parent, invokingState); 13758 } 13759 @Override public int getRuleIndex() { return RULE_reference; } 13760 @Override 13761 public void enterRule(ParseTreeListener listener) { 13762 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterReference(this); 13763 } 13764 @Override 13765 public void exitRule(ParseTreeListener listener) { 13766 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitReference(this); 13767 } 13768 @Override 13769 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13770 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitReference(this); 13771 else return visitor.visitChildren(this); 13772 } 13773 } 13774 13775 public final ReferenceContext reference() throws RecognitionException { 13776 ReferenceContext _localctx = new ReferenceContext(_ctx, getState()); 13777 enterRule(_localctx, 138, RULE_reference); 13778 int _la; 13779 try { 13780 int _alt; 13781 enterOuterAlt(_localctx, 1); 13782 { 13783 setState(1597); 13784 switch (_input.LA(1)) { 13785 case PACKAGE: 13786 { 13787 setState(1560); 13788 match(PACKAGE); 13789 setState(1564); 13790 _errHandler.sync(this); 13791 _alt = getInterpreter().adaptivePredict(_input,123,_ctx); 13792 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13793 if ( _alt==1 ) { 13794 { 13795 { 13796 setState(1561); 13797 _la = _input.LA(1); 13798 if ( !(_la==DOT || _la==CLASS) ) { 13799 _errHandler.recoverInline(this); 13800 } else { 13801 consume(); 13802 } 13803 } 13804 } 13805 } 13806 setState(1566); 13807 _errHandler.sync(this); 13808 _alt = getInterpreter().adaptivePredict(_input,123,_ctx); 13809 } 13810 setState(1568); 13811 _errHandler.sync(this); 13812 switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) { 13813 case 1: 13814 { 13815 setState(1567); 13816 match(HASH); 13817 } 13818 break; 13819 } 13820 setState(1571); 13821 _errHandler.sync(this); 13822 switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) { 13823 case 1: 13824 { 13825 setState(1570); 13826 match(MEMBER); 13827 } 13828 break; 13829 } 13830 setState(1574); 13831 _errHandler.sync(this); 13832 switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) { 13833 case 1: 13834 { 13835 setState(1573); 13836 parameters(); 13837 } 13838 break; 13839 } 13840 } 13841 break; 13842 case DOT: 13843 case CLASS: 13844 { 13845 setState(1577); 13846 _errHandler.sync(this); 13847 _alt = 1; 13848 do { 13849 switch (_alt) { 13850 case 1: 13851 { 13852 { 13853 setState(1576); 13854 _la = _input.LA(1); 13855 if ( !(_la==DOT || _la==CLASS) ) { 13856 _errHandler.recoverInline(this); 13857 } else { 13858 consume(); 13859 } 13860 } 13861 } 13862 break; 13863 default: 13864 throw new NoViableAltException(this); 13865 } 13866 setState(1579); 13867 _errHandler.sync(this); 13868 _alt = getInterpreter().adaptivePredict(_input,127,_ctx); 13869 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13870 setState(1582); 13871 _errHandler.sync(this); 13872 switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { 13873 case 1: 13874 { 13875 setState(1581); 13876 match(HASH); 13877 } 13878 break; 13879 } 13880 setState(1585); 13881 _errHandler.sync(this); 13882 switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) { 13883 case 1: 13884 { 13885 setState(1584); 13886 match(MEMBER); 13887 } 13888 break; 13889 } 13890 setState(1588); 13891 _errHandler.sync(this); 13892 switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) { 13893 case 1: 13894 { 13895 setState(1587); 13896 parameters(); 13897 } 13898 break; 13899 } 13900 } 13901 break; 13902 case HASH: 13903 case MEMBER: 13904 { 13905 setState(1591); 13906 _la = _input.LA(1); 13907 if (_la==HASH) { 13908 { 13909 setState(1590); 13910 match(HASH); 13911 } 13912 } 13913 13914 setState(1593); 13915 match(MEMBER); 13916 setState(1595); 13917 _errHandler.sync(this); 13918 switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { 13919 case 1: 13920 { 13921 setState(1594); 13922 parameters(); 13923 } 13924 break; 13925 } 13926 } 13927 break; 13928 default: 13929 throw new NoViableAltException(this); 13930 } 13931 } 13932 } 13933 catch (RecognitionException re) { 13934 _localctx.exception = re; 13935 _errHandler.reportError(this, re); 13936 _errHandler.recover(this, re); 13937 } 13938 finally { 13939 exitRule(); 13940 } 13941 return _localctx; 13942 } 13943 13944 public static class ParametersContext extends ParserRuleContext { 13945 public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); } 13946 public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); } 13947 public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); } 13948 public TerminalNode ARGUMENT(int i) { 13949 return getToken(JavadocParser.ARGUMENT, i); 13950 } 13951 public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); } 13952 public TerminalNode COMMA(int i) { 13953 return getToken(JavadocParser.COMMA, i); 13954 } 13955 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13956 public TerminalNode WS(int i) { 13957 return getToken(JavadocParser.WS, i); 13958 } 13959 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13960 public TerminalNode NEWLINE(int i) { 13961 return getToken(JavadocParser.NEWLINE, i); 13962 } 13963 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13964 public TerminalNode LEADING_ASTERISK(int i) { 13965 return getToken(JavadocParser.LEADING_ASTERISK, i); 13966 } 13967 public ParametersContext(ParserRuleContext parent, int invokingState) { 13968 super(parent, invokingState); 13969 } 13970 @Override public int getRuleIndex() { return RULE_parameters; } 13971 @Override 13972 public void enterRule(ParseTreeListener listener) { 13973 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParameters(this); 13974 } 13975 @Override 13976 public void exitRule(ParseTreeListener listener) { 13977 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParameters(this); 13978 } 13979 @Override 13980 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13981 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParameters(this); 13982 else return visitor.visitChildren(this); 13983 } 13984 } 13985 13986 public final ParametersContext parameters() throws RecognitionException { 13987 ParametersContext _localctx = new ParametersContext(_ctx, getState()); 13988 enterRule(_localctx, 140, RULE_parameters); 13989 int _la; 13990 try { 13991 enterOuterAlt(_localctx, 1); 13992 { 13993 setState(1599); 13994 match(LEFT_BRACE); 13995 setState(1603); 13996 _errHandler.sync(this); 13997 _la = _input.LA(1); 13998 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) { 13999 { 14000 { 14001 setState(1600); 14002 _la = _input.LA(1); 14003 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) { 14004 _errHandler.recoverInline(this); 14005 } else { 14006 consume(); 14007 } 14008 } 14009 } 14010 setState(1605); 14011 _errHandler.sync(this); 14012 _la = _input.LA(1); 14013 } 14014 setState(1606); 14015 match(RIGHT_BRACE); 14016 } 14017 } 14018 catch (RecognitionException re) { 14019 _localctx.exception = re; 14020 _errHandler.reportError(this, re); 14021 _errHandler.recover(this, re); 14022 } 14023 finally { 14024 exitRule(); 14025 } 14026 return _localctx; 14027 } 14028 14029 public static class JavadocTagContext extends ParserRuleContext { 14030 public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); } 14031 public DescriptionContext description() { 14032 return getRuleContext(DescriptionContext.class,0); 14033 } 14034 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14035 public TerminalNode WS(int i) { 14036 return getToken(JavadocParser.WS, i); 14037 } 14038 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14039 public TerminalNode NEWLINE(int i) { 14040 return getToken(JavadocParser.NEWLINE, i); 14041 } 14042 public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); } 14043 public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); } 14044 public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); } 14045 public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); } 14046 public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); } 14047 public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); } 14048 public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); } 14049 public ReferenceContext reference() { 14050 return getRuleContext(ReferenceContext.class,0); 14051 } 14052 public List<TerminalNode> STRING() { return getTokens(JavadocParser.STRING); } 14053 public TerminalNode STRING(int i) { 14054 return getToken(JavadocParser.STRING, i); 14055 } 14056 public List<HtmlElementContext> htmlElement() { 14057 return getRuleContexts(HtmlElementContext.class); 14058 } 14059 public HtmlElementContext htmlElement(int i) { 14060 return getRuleContext(HtmlElementContext.class,i); 14061 } 14062 public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); } 14063 public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); } 14064 public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); } 14065 public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); } 14066 public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); } 14067 public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); } 14068 public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); } 14069 public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); } 14070 public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); } 14071 public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); } 14072 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 14073 public JavadocTagContext(ParserRuleContext parent, int invokingState) { 14074 super(parent, invokingState); 14075 } 14076 @Override public int getRuleIndex() { return RULE_javadocTag; } 14077 @Override 14078 public void enterRule(ParseTreeListener listener) { 14079 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocTag(this); 14080 } 14081 @Override 14082 public void exitRule(ParseTreeListener listener) { 14083 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocTag(this); 14084 } 14085 @Override 14086 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14087 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocTag(this); 14088 else return visitor.visitChildren(this); 14089 } 14090 } 14091 14092 public final JavadocTagContext javadocTag() throws RecognitionException { 14093 JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState()); 14094 enterRule(_localctx, 142, RULE_javadocTag); 14095 int _la; 14096 try { 14097 int _alt; 14098 setState(1802); 14099 switch (_input.LA(1)) { 14100 case AUTHOR_LITERAL: 14101 enterOuterAlt(_localctx, 1); 14102 { 14103 setState(1608); 14104 match(AUTHOR_LITERAL); 14105 setState(1612); 14106 _errHandler.sync(this); 14107 _alt = getInterpreter().adaptivePredict(_input,135,_ctx); 14108 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14109 if ( _alt==1 ) { 14110 { 14111 { 14112 setState(1609); 14113 _la = _input.LA(1); 14114 if ( !(_la==WS || _la==NEWLINE) ) { 14115 _errHandler.recoverInline(this); 14116 } else { 14117 consume(); 14118 } 14119 } 14120 } 14121 } 14122 setState(1614); 14123 _errHandler.sync(this); 14124 _alt = getInterpreter().adaptivePredict(_input,135,_ctx); 14125 } 14126 setState(1616); 14127 _errHandler.sync(this); 14128 switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) { 14129 case 1: 14130 { 14131 setState(1615); 14132 description(); 14133 } 14134 break; 14135 } 14136 } 14137 break; 14138 case DEPRECATED_LITERAL: 14139 enterOuterAlt(_localctx, 2); 14140 { 14141 setState(1618); 14142 match(DEPRECATED_LITERAL); 14143 setState(1622); 14144 _errHandler.sync(this); 14145 _alt = getInterpreter().adaptivePredict(_input,137,_ctx); 14146 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14147 if ( _alt==1 ) { 14148 { 14149 { 14150 setState(1619); 14151 _la = _input.LA(1); 14152 if ( !(_la==WS || _la==NEWLINE) ) { 14153 _errHandler.recoverInline(this); 14154 } else { 14155 consume(); 14156 } 14157 } 14158 } 14159 } 14160 setState(1624); 14161 _errHandler.sync(this); 14162 _alt = getInterpreter().adaptivePredict(_input,137,_ctx); 14163 } 14164 setState(1626); 14165 _errHandler.sync(this); 14166 switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { 14167 case 1: 14168 { 14169 setState(1625); 14170 description(); 14171 } 14172 break; 14173 } 14174 } 14175 break; 14176 case EXCEPTION_LITERAL: 14177 enterOuterAlt(_localctx, 3); 14178 { 14179 setState(1628); 14180 match(EXCEPTION_LITERAL); 14181 setState(1632); 14182 _errHandler.sync(this); 14183 _alt = getInterpreter().adaptivePredict(_input,139,_ctx); 14184 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14185 if ( _alt==1 ) { 14186 { 14187 { 14188 setState(1629); 14189 _la = _input.LA(1); 14190 if ( !(_la==WS || _la==NEWLINE) ) { 14191 _errHandler.recoverInline(this); 14192 } else { 14193 consume(); 14194 } 14195 } 14196 } 14197 } 14198 setState(1634); 14199 _errHandler.sync(this); 14200 _alt = getInterpreter().adaptivePredict(_input,139,_ctx); 14201 } 14202 setState(1636); 14203 _errHandler.sync(this); 14204 switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) { 14205 case 1: 14206 { 14207 setState(1635); 14208 match(CLASS_NAME); 14209 } 14210 break; 14211 } 14212 setState(1641); 14213 _errHandler.sync(this); 14214 _alt = getInterpreter().adaptivePredict(_input,141,_ctx); 14215 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14216 if ( _alt==1 ) { 14217 { 14218 { 14219 setState(1638); 14220 _la = _input.LA(1); 14221 if ( !(_la==WS || _la==NEWLINE) ) { 14222 _errHandler.recoverInline(this); 14223 } else { 14224 consume(); 14225 } 14226 } 14227 } 14228 } 14229 setState(1643); 14230 _errHandler.sync(this); 14231 _alt = getInterpreter().adaptivePredict(_input,141,_ctx); 14232 } 14233 setState(1645); 14234 _errHandler.sync(this); 14235 switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) { 14236 case 1: 14237 { 14238 setState(1644); 14239 description(); 14240 } 14241 break; 14242 } 14243 } 14244 break; 14245 case PARAM_LITERAL: 14246 enterOuterAlt(_localctx, 4); 14247 { 14248 setState(1647); 14249 match(PARAM_LITERAL); 14250 setState(1651); 14251 _errHandler.sync(this); 14252 _alt = getInterpreter().adaptivePredict(_input,143,_ctx); 14253 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14254 if ( _alt==1 ) { 14255 { 14256 { 14257 setState(1648); 14258 _la = _input.LA(1); 14259 if ( !(_la==WS || _la==NEWLINE) ) { 14260 _errHandler.recoverInline(this); 14261 } else { 14262 consume(); 14263 } 14264 } 14265 } 14266 } 14267 setState(1653); 14268 _errHandler.sync(this); 14269 _alt = getInterpreter().adaptivePredict(_input,143,_ctx); 14270 } 14271 setState(1655); 14272 _errHandler.sync(this); 14273 switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { 14274 case 1: 14275 { 14276 setState(1654); 14277 match(PARAMETER_NAME); 14278 } 14279 break; 14280 } 14281 setState(1660); 14282 _errHandler.sync(this); 14283 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 14284 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14285 if ( _alt==1 ) { 14286 { 14287 { 14288 setState(1657); 14289 _la = _input.LA(1); 14290 if ( !(_la==WS || _la==NEWLINE) ) { 14291 _errHandler.recoverInline(this); 14292 } else { 14293 consume(); 14294 } 14295 } 14296 } 14297 } 14298 setState(1662); 14299 _errHandler.sync(this); 14300 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 14301 } 14302 setState(1664); 14303 _errHandler.sync(this); 14304 switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { 14305 case 1: 14306 { 14307 setState(1663); 14308 description(); 14309 } 14310 break; 14311 } 14312 } 14313 break; 14314 case RETURN_LITERAL: 14315 enterOuterAlt(_localctx, 5); 14316 { 14317 setState(1666); 14318 match(RETURN_LITERAL); 14319 setState(1670); 14320 _errHandler.sync(this); 14321 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 14322 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14323 if ( _alt==1 ) { 14324 { 14325 { 14326 setState(1667); 14327 _la = _input.LA(1); 14328 if ( !(_la==WS || _la==NEWLINE) ) { 14329 _errHandler.recoverInline(this); 14330 } else { 14331 consume(); 14332 } 14333 } 14334 } 14335 } 14336 setState(1672); 14337 _errHandler.sync(this); 14338 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 14339 } 14340 setState(1674); 14341 _errHandler.sync(this); 14342 switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { 14343 case 1: 14344 { 14345 setState(1673); 14346 description(); 14347 } 14348 break; 14349 } 14350 } 14351 break; 14352 case SEE_LITERAL: 14353 enterOuterAlt(_localctx, 6); 14354 { 14355 setState(1676); 14356 match(SEE_LITERAL); 14357 setState(1680); 14358 _errHandler.sync(this); 14359 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 14360 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14361 if ( _alt==1 ) { 14362 { 14363 { 14364 setState(1677); 14365 _la = _input.LA(1); 14366 if ( !(_la==WS || _la==NEWLINE) ) { 14367 _errHandler.recoverInline(this); 14368 } else { 14369 consume(); 14370 } 14371 } 14372 } 14373 } 14374 setState(1682); 14375 _errHandler.sync(this); 14376 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 14377 } 14378 setState(1684); 14379 _errHandler.sync(this); 14380 switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { 14381 case 1: 14382 { 14383 setState(1683); 14384 reference(); 14385 } 14386 break; 14387 } 14388 setState(1690); 14389 _errHandler.sync(this); 14390 _alt = getInterpreter().adaptivePredict(_input,152,_ctx); 14391 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14392 if ( _alt==1 ) { 14393 { 14394 setState(1688); 14395 switch (_input.LA(1)) { 14396 case STRING: 14397 { 14398 setState(1686); 14399 match(STRING); 14400 } 14401 break; 14402 case OPEN: 14403 { 14404 setState(1687); 14405 htmlElement(); 14406 } 14407 break; 14408 default: 14409 throw new NoViableAltException(this); 14410 } 14411 } 14412 } 14413 setState(1692); 14414 _errHandler.sync(this); 14415 _alt = getInterpreter().adaptivePredict(_input,152,_ctx); 14416 } 14417 setState(1696); 14418 _errHandler.sync(this); 14419 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 14420 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14421 if ( _alt==1 ) { 14422 { 14423 { 14424 setState(1693); 14425 _la = _input.LA(1); 14426 if ( !(_la==WS || _la==NEWLINE) ) { 14427 _errHandler.recoverInline(this); 14428 } else { 14429 consume(); 14430 } 14431 } 14432 } 14433 } 14434 setState(1698); 14435 _errHandler.sync(this); 14436 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 14437 } 14438 setState(1700); 14439 _errHandler.sync(this); 14440 switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { 14441 case 1: 14442 { 14443 setState(1699); 14444 description(); 14445 } 14446 break; 14447 } 14448 } 14449 break; 14450 case SERIAL_LITERAL: 14451 enterOuterAlt(_localctx, 7); 14452 { 14453 setState(1702); 14454 match(SERIAL_LITERAL); 14455 setState(1706); 14456 _errHandler.sync(this); 14457 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 14458 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14459 if ( _alt==1 ) { 14460 { 14461 { 14462 setState(1703); 14463 _la = _input.LA(1); 14464 if ( !(_la==WS || _la==NEWLINE) ) { 14465 _errHandler.recoverInline(this); 14466 } else { 14467 consume(); 14468 } 14469 } 14470 } 14471 } 14472 setState(1708); 14473 _errHandler.sync(this); 14474 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 14475 } 14476 setState(1710); 14477 _errHandler.sync(this); 14478 switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { 14479 case 1: 14480 { 14481 setState(1709); 14482 _la = _input.LA(1); 14483 if ( !(_la==LITERAL_INCLUDE || _la==LITERAL_EXCLUDE) ) { 14484 _errHandler.recoverInline(this); 14485 } else { 14486 consume(); 14487 } 14488 } 14489 break; 14490 } 14491 setState(1713); 14492 _errHandler.sync(this); 14493 switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { 14494 case 1: 14495 { 14496 setState(1712); 14497 description(); 14498 } 14499 break; 14500 } 14501 } 14502 break; 14503 case SERIAL_DATA_LITERAL: 14504 enterOuterAlt(_localctx, 8); 14505 { 14506 setState(1715); 14507 match(SERIAL_DATA_LITERAL); 14508 setState(1719); 14509 _errHandler.sync(this); 14510 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14511 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14512 if ( _alt==1 ) { 14513 { 14514 { 14515 setState(1716); 14516 _la = _input.LA(1); 14517 if ( !(_la==WS || _la==NEWLINE) ) { 14518 _errHandler.recoverInline(this); 14519 } else { 14520 consume(); 14521 } 14522 } 14523 } 14524 } 14525 setState(1721); 14526 _errHandler.sync(this); 14527 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14528 } 14529 setState(1723); 14530 _errHandler.sync(this); 14531 switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) { 14532 case 1: 14533 { 14534 setState(1722); 14535 description(); 14536 } 14537 break; 14538 } 14539 } 14540 break; 14541 case SERIAL_FIELD_LITERAL: 14542 enterOuterAlt(_localctx, 9); 14543 { 14544 setState(1725); 14545 match(SERIAL_FIELD_LITERAL); 14546 setState(1729); 14547 _errHandler.sync(this); 14548 _alt = getInterpreter().adaptivePredict(_input,160,_ctx); 14549 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14550 if ( _alt==1 ) { 14551 { 14552 { 14553 setState(1726); 14554 _la = _input.LA(1); 14555 if ( !(_la==WS || _la==NEWLINE) ) { 14556 _errHandler.recoverInline(this); 14557 } else { 14558 consume(); 14559 } 14560 } 14561 } 14562 } 14563 setState(1731); 14564 _errHandler.sync(this); 14565 _alt = getInterpreter().adaptivePredict(_input,160,_ctx); 14566 } 14567 setState(1733); 14568 _errHandler.sync(this); 14569 switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) { 14570 case 1: 14571 { 14572 setState(1732); 14573 match(FIELD_NAME); 14574 } 14575 break; 14576 } 14577 setState(1738); 14578 _errHandler.sync(this); 14579 _alt = getInterpreter().adaptivePredict(_input,162,_ctx); 14580 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14581 if ( _alt==1 ) { 14582 { 14583 { 14584 setState(1735); 14585 _la = _input.LA(1); 14586 if ( !(_la==WS || _la==NEWLINE) ) { 14587 _errHandler.recoverInline(this); 14588 } else { 14589 consume(); 14590 } 14591 } 14592 } 14593 } 14594 setState(1740); 14595 _errHandler.sync(this); 14596 _alt = getInterpreter().adaptivePredict(_input,162,_ctx); 14597 } 14598 setState(1742); 14599 _errHandler.sync(this); 14600 switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) { 14601 case 1: 14602 { 14603 setState(1741); 14604 match(FIELD_TYPE); 14605 } 14606 break; 14607 } 14608 setState(1747); 14609 _errHandler.sync(this); 14610 _alt = getInterpreter().adaptivePredict(_input,164,_ctx); 14611 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14612 if ( _alt==1 ) { 14613 { 14614 { 14615 setState(1744); 14616 _la = _input.LA(1); 14617 if ( !(_la==WS || _la==NEWLINE) ) { 14618 _errHandler.recoverInline(this); 14619 } else { 14620 consume(); 14621 } 14622 } 14623 } 14624 } 14625 setState(1749); 14626 _errHandler.sync(this); 14627 _alt = getInterpreter().adaptivePredict(_input,164,_ctx); 14628 } 14629 setState(1751); 14630 _errHandler.sync(this); 14631 switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) { 14632 case 1: 14633 { 14634 setState(1750); 14635 description(); 14636 } 14637 break; 14638 } 14639 } 14640 break; 14641 case SINCE_LITERAL: 14642 enterOuterAlt(_localctx, 10); 14643 { 14644 setState(1753); 14645 match(SINCE_LITERAL); 14646 setState(1757); 14647 _errHandler.sync(this); 14648 _alt = getInterpreter().adaptivePredict(_input,166,_ctx); 14649 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14650 if ( _alt==1 ) { 14651 { 14652 { 14653 setState(1754); 14654 _la = _input.LA(1); 14655 if ( !(_la==WS || _la==NEWLINE) ) { 14656 _errHandler.recoverInline(this); 14657 } else { 14658 consume(); 14659 } 14660 } 14661 } 14662 } 14663 setState(1759); 14664 _errHandler.sync(this); 14665 _alt = getInterpreter().adaptivePredict(_input,166,_ctx); 14666 } 14667 setState(1761); 14668 _errHandler.sync(this); 14669 switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { 14670 case 1: 14671 { 14672 setState(1760); 14673 description(); 14674 } 14675 break; 14676 } 14677 } 14678 break; 14679 case THROWS_LITERAL: 14680 enterOuterAlt(_localctx, 11); 14681 { 14682 setState(1763); 14683 match(THROWS_LITERAL); 14684 setState(1767); 14685 _errHandler.sync(this); 14686 _alt = getInterpreter().adaptivePredict(_input,168,_ctx); 14687 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14688 if ( _alt==1 ) { 14689 { 14690 { 14691 setState(1764); 14692 _la = _input.LA(1); 14693 if ( !(_la==WS || _la==NEWLINE) ) { 14694 _errHandler.recoverInline(this); 14695 } else { 14696 consume(); 14697 } 14698 } 14699 } 14700 } 14701 setState(1769); 14702 _errHandler.sync(this); 14703 _alt = getInterpreter().adaptivePredict(_input,168,_ctx); 14704 } 14705 setState(1771); 14706 _errHandler.sync(this); 14707 switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) { 14708 case 1: 14709 { 14710 setState(1770); 14711 match(CLASS_NAME); 14712 } 14713 break; 14714 } 14715 setState(1776); 14716 _errHandler.sync(this); 14717 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14718 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14719 if ( _alt==1 ) { 14720 { 14721 { 14722 setState(1773); 14723 _la = _input.LA(1); 14724 if ( !(_la==WS || _la==NEWLINE) ) { 14725 _errHandler.recoverInline(this); 14726 } else { 14727 consume(); 14728 } 14729 } 14730 } 14731 } 14732 setState(1778); 14733 _errHandler.sync(this); 14734 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14735 } 14736 setState(1780); 14737 _errHandler.sync(this); 14738 switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) { 14739 case 1: 14740 { 14741 setState(1779); 14742 description(); 14743 } 14744 break; 14745 } 14746 } 14747 break; 14748 case VERSION_LITERAL: 14749 enterOuterAlt(_localctx, 12); 14750 { 14751 setState(1782); 14752 match(VERSION_LITERAL); 14753 setState(1786); 14754 _errHandler.sync(this); 14755 _alt = getInterpreter().adaptivePredict(_input,172,_ctx); 14756 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14757 if ( _alt==1 ) { 14758 { 14759 { 14760 setState(1783); 14761 _la = _input.LA(1); 14762 if ( !(_la==WS || _la==NEWLINE) ) { 14763 _errHandler.recoverInline(this); 14764 } else { 14765 consume(); 14766 } 14767 } 14768 } 14769 } 14770 setState(1788); 14771 _errHandler.sync(this); 14772 _alt = getInterpreter().adaptivePredict(_input,172,_ctx); 14773 } 14774 setState(1790); 14775 _errHandler.sync(this); 14776 switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) { 14777 case 1: 14778 { 14779 setState(1789); 14780 description(); 14781 } 14782 break; 14783 } 14784 } 14785 break; 14786 case CUSTOM_NAME: 14787 enterOuterAlt(_localctx, 13); 14788 { 14789 setState(1792); 14790 match(CUSTOM_NAME); 14791 setState(1796); 14792 _errHandler.sync(this); 14793 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 14794 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14795 if ( _alt==1 ) { 14796 { 14797 { 14798 setState(1793); 14799 _la = _input.LA(1); 14800 if ( !(_la==WS || _la==NEWLINE) ) { 14801 _errHandler.recoverInline(this); 14802 } else { 14803 consume(); 14804 } 14805 } 14806 } 14807 } 14808 setState(1798); 14809 _errHandler.sync(this); 14810 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 14811 } 14812 setState(1800); 14813 _errHandler.sync(this); 14814 switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) { 14815 case 1: 14816 { 14817 setState(1799); 14818 description(); 14819 } 14820 break; 14821 } 14822 } 14823 break; 14824 default: 14825 throw new NoViableAltException(this); 14826 } 14827 } 14828 catch (RecognitionException re) { 14829 _localctx.exception = re; 14830 _errHandler.reportError(this, re); 14831 _errHandler.recover(this, re); 14832 } 14833 finally { 14834 exitRule(); 14835 } 14836 return _localctx; 14837 } 14838 14839 public static class JavadocInlineTagContext extends ParserRuleContext { 14840 public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); } 14841 public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); } 14842 public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); } 14843 public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); } 14844 public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); } 14845 public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); } 14846 public ReferenceContext reference() { 14847 return getRuleContext(ReferenceContext.class,0); 14848 } 14849 public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); } 14850 public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); } 14851 public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); } 14852 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 14853 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14854 public TerminalNode WS(int i) { 14855 return getToken(JavadocParser.WS, i); 14856 } 14857 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14858 public TerminalNode NEWLINE(int i) { 14859 return getToken(JavadocParser.NEWLINE, i); 14860 } 14861 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14862 public TerminalNode LEADING_ASTERISK(int i) { 14863 return getToken(JavadocParser.LEADING_ASTERISK, i); 14864 } 14865 public List<TextContext> text() { 14866 return getRuleContexts(TextContext.class); 14867 } 14868 public TextContext text(int i) { 14869 return getRuleContext(TextContext.class,i); 14870 } 14871 public DescriptionContext description() { 14872 return getRuleContext(DescriptionContext.class,0); 14873 } 14874 public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) { 14875 super(parent, invokingState); 14876 } 14877 @Override public int getRuleIndex() { return RULE_javadocInlineTag; } 14878 @Override 14879 public void enterRule(ParseTreeListener listener) { 14880 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocInlineTag(this); 14881 } 14882 @Override 14883 public void exitRule(ParseTreeListener listener) { 14884 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocInlineTag(this); 14885 } 14886 @Override 14887 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14888 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocInlineTag(this); 14889 else return visitor.visitChildren(this); 14890 } 14891 } 14892 14893 public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException { 14894 JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState()); 14895 enterRule(_localctx, 144, RULE_javadocInlineTag); 14896 int _la; 14897 try { 14898 int _alt; 14899 enterOuterAlt(_localctx, 1); 14900 { 14901 setState(1804); 14902 match(JAVADOC_INLINE_TAG_START); 14903 setState(1881); 14904 switch (_input.LA(1)) { 14905 case CODE_LITERAL: 14906 { 14907 setState(1805); 14908 match(CODE_LITERAL); 14909 setState(1812); 14910 _errHandler.sync(this); 14911 _la = _input.LA(1); 14912 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 14913 { 14914 setState(1810); 14915 _errHandler.sync(this); 14916 switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) { 14917 case 1: 14918 { 14919 setState(1806); 14920 match(WS); 14921 } 14922 break; 14923 case 2: 14924 { 14925 setState(1807); 14926 match(NEWLINE); 14927 } 14928 break; 14929 case 3: 14930 { 14931 setState(1808); 14932 match(LEADING_ASTERISK); 14933 } 14934 break; 14935 case 4: 14936 { 14937 setState(1809); 14938 text(); 14939 } 14940 break; 14941 } 14942 } 14943 setState(1814); 14944 _errHandler.sync(this); 14945 _la = _input.LA(1); 14946 } 14947 } 14948 break; 14949 case DOC_ROOT_LITERAL: 14950 { 14951 setState(1815); 14952 match(DOC_ROOT_LITERAL); 14953 setState(1819); 14954 _errHandler.sync(this); 14955 _la = _input.LA(1); 14956 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 14957 { 14958 { 14959 setState(1816); 14960 _la = _input.LA(1); 14961 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14962 _errHandler.recoverInline(this); 14963 } else { 14964 consume(); 14965 } 14966 } 14967 } 14968 setState(1821); 14969 _errHandler.sync(this); 14970 _la = _input.LA(1); 14971 } 14972 } 14973 break; 14974 case INHERIT_DOC_LITERAL: 14975 { 14976 setState(1822); 14977 match(INHERIT_DOC_LITERAL); 14978 setState(1826); 14979 _errHandler.sync(this); 14980 _la = _input.LA(1); 14981 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 14982 { 14983 { 14984 setState(1823); 14985 _la = _input.LA(1); 14986 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14987 _errHandler.recoverInline(this); 14988 } else { 14989 consume(); 14990 } 14991 } 14992 } 14993 setState(1828); 14994 _errHandler.sync(this); 14995 _la = _input.LA(1); 14996 } 14997 } 14998 break; 14999 case LINK_LITERAL: 15000 { 15001 setState(1829); 15002 match(LINK_LITERAL); 15003 setState(1833); 15004 _errHandler.sync(this); 15005 _la = _input.LA(1); 15006 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15007 { 15008 { 15009 setState(1830); 15010 _la = _input.LA(1); 15011 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15012 _errHandler.recoverInline(this); 15013 } else { 15014 consume(); 15015 } 15016 } 15017 } 15018 setState(1835); 15019 _errHandler.sync(this); 15020 _la = _input.LA(1); 15021 } 15022 setState(1836); 15023 reference(); 15024 setState(1838); 15025 _errHandler.sync(this); 15026 switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { 15027 case 1: 15028 { 15029 setState(1837); 15030 description(); 15031 } 15032 break; 15033 } 15034 } 15035 break; 15036 case LINKPLAIN_LITERAL: 15037 { 15038 setState(1840); 15039 match(LINKPLAIN_LITERAL); 15040 setState(1844); 15041 _errHandler.sync(this); 15042 _la = _input.LA(1); 15043 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15044 { 15045 { 15046 setState(1841); 15047 _la = _input.LA(1); 15048 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15049 _errHandler.recoverInline(this); 15050 } else { 15051 consume(); 15052 } 15053 } 15054 } 15055 setState(1846); 15056 _errHandler.sync(this); 15057 _la = _input.LA(1); 15058 } 15059 setState(1847); 15060 reference(); 15061 setState(1849); 15062 _errHandler.sync(this); 15063 switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) { 15064 case 1: 15065 { 15066 setState(1848); 15067 description(); 15068 } 15069 break; 15070 } 15071 } 15072 break; 15073 case LITERAL_LITERAL: 15074 { 15075 setState(1851); 15076 match(LITERAL_LITERAL); 15077 setState(1858); 15078 _errHandler.sync(this); 15079 _la = _input.LA(1); 15080 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15081 { 15082 setState(1856); 15083 _errHandler.sync(this); 15084 switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) { 15085 case 1: 15086 { 15087 setState(1852); 15088 match(WS); 15089 } 15090 break; 15091 case 2: 15092 { 15093 setState(1853); 15094 match(NEWLINE); 15095 } 15096 break; 15097 case 3: 15098 { 15099 setState(1854); 15100 match(LEADING_ASTERISK); 15101 } 15102 break; 15103 case 4: 15104 { 15105 setState(1855); 15106 text(); 15107 } 15108 break; 15109 } 15110 } 15111 setState(1860); 15112 _errHandler.sync(this); 15113 _la = _input.LA(1); 15114 } 15115 } 15116 break; 15117 case VALUE_LITERAL: 15118 { 15119 setState(1861); 15120 match(VALUE_LITERAL); 15121 setState(1865); 15122 _errHandler.sync(this); 15123 _la = _input.LA(1); 15124 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15125 { 15126 { 15127 setState(1862); 15128 _la = _input.LA(1); 15129 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15130 _errHandler.recoverInline(this); 15131 } else { 15132 consume(); 15133 } 15134 } 15135 } 15136 setState(1867); 15137 _errHandler.sync(this); 15138 _la = _input.LA(1); 15139 } 15140 setState(1869); 15141 _la = _input.LA(1); 15142 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << DOT) | (1L << HASH) | (1L << CLASS) | (1L << MEMBER))) != 0)) { 15143 { 15144 setState(1868); 15145 reference(); 15146 } 15147 } 15148 15149 } 15150 break; 15151 case CUSTOM_NAME: 15152 { 15153 setState(1871); 15154 match(CUSTOM_NAME); 15155 setState(1875); 15156 _errHandler.sync(this); 15157 _alt = getInterpreter().adaptivePredict(_input,189,_ctx); 15158 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15159 if ( _alt==1 ) { 15160 { 15161 { 15162 setState(1872); 15163 _la = _input.LA(1); 15164 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15165 _errHandler.recoverInline(this); 15166 } else { 15167 consume(); 15168 } 15169 } 15170 } 15171 } 15172 setState(1877); 15173 _errHandler.sync(this); 15174 _alt = getInterpreter().adaptivePredict(_input,189,_ctx); 15175 } 15176 setState(1879); 15177 _errHandler.sync(this); 15178 switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) { 15179 case 1: 15180 { 15181 setState(1878); 15182 description(); 15183 } 15184 break; 15185 } 15186 } 15187 break; 15188 default: 15189 throw new NoViableAltException(this); 15190 } 15191 setState(1883); 15192 match(JAVADOC_INLINE_TAG_END); 15193 } 15194 } 15195 catch (RecognitionException re) { 15196 _localctx.exception = re; 15197 _errHandler.reportError(this, re); 15198 _errHandler.recover(this, re); 15199 } 15200 finally { 15201 exitRule(); 15202 } 15203 return _localctx; 15204 } 15205 15206 public static class HtmlCommentContext extends ParserRuleContext { 15207 public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); } 15208 public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); } 15209 public List<TextContext> text() { 15210 return getRuleContexts(TextContext.class); 15211 } 15212 public TextContext text(int i) { 15213 return getRuleContext(TextContext.class,i); 15214 } 15215 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15216 public TerminalNode NEWLINE(int i) { 15217 return getToken(JavadocParser.NEWLINE, i); 15218 } 15219 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15220 public TerminalNode LEADING_ASTERISK(int i) { 15221 return getToken(JavadocParser.LEADING_ASTERISK, i); 15222 } 15223 public HtmlCommentContext(ParserRuleContext parent, int invokingState) { 15224 super(parent, invokingState); 15225 } 15226 @Override public int getRuleIndex() { return RULE_htmlComment; } 15227 @Override 15228 public void enterRule(ParseTreeListener listener) { 15229 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlComment(this); 15230 } 15231 @Override 15232 public void exitRule(ParseTreeListener listener) { 15233 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlComment(this); 15234 } 15235 @Override 15236 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15237 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlComment(this); 15238 else return visitor.visitChildren(this); 15239 } 15240 } 15241 15242 public final HtmlCommentContext htmlComment() throws RecognitionException { 15243 HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState()); 15244 enterRule(_localctx, 146, RULE_htmlComment); 15245 int _la; 15246 try { 15247 enterOuterAlt(_localctx, 1); 15248 { 15249 setState(1885); 15250 match(HTML_COMMENT_START); 15251 setState(1891); 15252 _errHandler.sync(this); 15253 _la = _input.LA(1); 15254 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15255 { 15256 setState(1889); 15257 switch (_input.LA(1)) { 15258 case WS: 15259 case CHAR: 15260 { 15261 setState(1886); 15262 text(); 15263 } 15264 break; 15265 case NEWLINE: 15266 { 15267 setState(1887); 15268 match(NEWLINE); 15269 } 15270 break; 15271 case LEADING_ASTERISK: 15272 { 15273 setState(1888); 15274 match(LEADING_ASTERISK); 15275 } 15276 break; 15277 default: 15278 throw new NoViableAltException(this); 15279 } 15280 } 15281 setState(1893); 15282 _errHandler.sync(this); 15283 _la = _input.LA(1); 15284 } 15285 setState(1894); 15286 match(HTML_COMMENT_END); 15287 } 15288 } 15289 catch (RecognitionException re) { 15290 _localctx.exception = re; 15291 _errHandler.reportError(this, re); 15292 _errHandler.recover(this, re); 15293 } 15294 finally { 15295 exitRule(); 15296 } 15297 return _localctx; 15298 } 15299 15300 public static class TextContext extends ParserRuleContext { 15301 public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); } 15302 public TerminalNode CHAR(int i) { 15303 return getToken(JavadocParser.CHAR, i); 15304 } 15305 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15306 public TerminalNode WS(int i) { 15307 return getToken(JavadocParser.WS, i); 15308 } 15309 public TextContext(ParserRuleContext parent, int invokingState) { 15310 super(parent, invokingState); 15311 } 15312 @Override public int getRuleIndex() { return RULE_text; } 15313 @Override 15314 public void enterRule(ParseTreeListener listener) { 15315 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterText(this); 15316 } 15317 @Override 15318 public void exitRule(ParseTreeListener listener) { 15319 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitText(this); 15320 } 15321 @Override 15322 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15323 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitText(this); 15324 else return visitor.visitChildren(this); 15325 } 15326 } 15327 15328 public final TextContext text() throws RecognitionException { 15329 TextContext _localctx = new TextContext(_ctx, getState()); 15330 enterRule(_localctx, 148, RULE_text); 15331 int _la; 15332 try { 15333 int _alt; 15334 enterOuterAlt(_localctx, 1); 15335 { 15336 setState(1898); 15337 _errHandler.sync(this); 15338 _alt = 1; 15339 do { 15340 switch (_alt) { 15341 case 1: 15342 { 15343 { 15344 setState(1896); 15345 _la = _input.LA(1); 15346 if ( !(_la==WS || _la==CHAR) ) { 15347 _errHandler.recoverInline(this); 15348 } else { 15349 consume(); 15350 } 15351 15352 _la = _input.LA(1); 15353 if ((_la != WS) && (_la != CHAR)) return _localctx; 15354 else if (_alt == 1) continue; 15355 15356 } 15357 } 15358 break; 15359 default: 15360 throw new NoViableAltException(this); 15361 } 15362 setState(1900); 15363 _errHandler.sync(this); 15364 _alt = getInterpreter().adaptivePredict(_input,194,_ctx); 15365 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15366 } 15367 } 15368 catch (RecognitionException re) { 15369 _localctx.exception = re; 15370 _errHandler.reportError(this, re); 15371 _errHandler.recover(this, re); 15372 } 15373 finally { 15374 exitRule(); 15375 } 15376 return _localctx; 15377 } 15378 15379 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { 15380 switch (ruleIndex) { 15381 case 0: 15382 return javadoc_sempred((JavadocContext)_localctx, predIndex); 15383 case 5: 15384 return htmlTag_sempred((HtmlTagContext)_localctx, predIndex); 15385 case 8: 15386 return paragraph_sempred((ParagraphContext)_localctx, predIndex); 15387 case 11: 15388 return li_sempred((LiContext)_localctx, predIndex); 15389 case 14: 15390 return tr_sempred((TrContext)_localctx, predIndex); 15391 case 17: 15392 return td_sempred((TdContext)_localctx, predIndex); 15393 case 20: 15394 return th_sempred((ThContext)_localctx, predIndex); 15395 case 23: 15396 return body_sempred((BodyContext)_localctx, predIndex); 15397 case 26: 15398 return colgroup_sempred((ColgroupContext)_localctx, predIndex); 15399 case 29: 15400 return dd_sempred((DdContext)_localctx, predIndex); 15401 case 32: 15402 return dt_sempred((DtContext)_localctx, predIndex); 15403 case 35: 15404 return head_sempred((HeadContext)_localctx, predIndex); 15405 case 38: 15406 return html_sempred((HtmlContext)_localctx, predIndex); 15407 case 41: 15408 return option_sempred((OptionContext)_localctx, predIndex); 15409 case 44: 15410 return tbody_sempred((TbodyContext)_localctx, predIndex); 15411 case 47: 15412 return tfoot_sempred((TfootContext)_localctx, predIndex); 15413 case 50: 15414 return thead_sempred((TheadContext)_localctx, predIndex); 15415 case 68: 15416 return description_sempred((DescriptionContext)_localctx, predIndex); 15417 } 15418 return true; 15419 } 15420 private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) { 15421 switch (predIndex) { 15422 case 0: 15423 return !isNextJavadocTag(); 15424 } 15425 return true; 15426 } 15427 private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) { 15428 switch (predIndex) { 15429 case 1: 15430 return !isNextJavadocTag(); 15431 case 2: 15432 return !isNextJavadocTag(); 15433 } 15434 return true; 15435 } 15436 private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) { 15437 switch (predIndex) { 15438 case 3: 15439 return !isNextJavadocTag(); 15440 } 15441 return true; 15442 } 15443 private boolean li_sempred(LiContext _localctx, int predIndex) { 15444 switch (predIndex) { 15445 case 4: 15446 return !isNextJavadocTag(); 15447 } 15448 return true; 15449 } 15450 private boolean tr_sempred(TrContext _localctx, int predIndex) { 15451 switch (predIndex) { 15452 case 5: 15453 return !isNextJavadocTag(); 15454 } 15455 return true; 15456 } 15457 private boolean td_sempred(TdContext _localctx, int predIndex) { 15458 switch (predIndex) { 15459 case 6: 15460 return !isNextJavadocTag(); 15461 } 15462 return true; 15463 } 15464 private boolean th_sempred(ThContext _localctx, int predIndex) { 15465 switch (predIndex) { 15466 case 7: 15467 return !isNextJavadocTag(); 15468 } 15469 return true; 15470 } 15471 private boolean body_sempred(BodyContext _localctx, int predIndex) { 15472 switch (predIndex) { 15473 case 8: 15474 return !isNextJavadocTag(); 15475 } 15476 return true; 15477 } 15478 private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) { 15479 switch (predIndex) { 15480 case 9: 15481 return !isNextJavadocTag(); 15482 } 15483 return true; 15484 } 15485 private boolean dd_sempred(DdContext _localctx, int predIndex) { 15486 switch (predIndex) { 15487 case 10: 15488 return !isNextJavadocTag(); 15489 } 15490 return true; 15491 } 15492 private boolean dt_sempred(DtContext _localctx, int predIndex) { 15493 switch (predIndex) { 15494 case 11: 15495 return !isNextJavadocTag(); 15496 } 15497 return true; 15498 } 15499 private boolean head_sempred(HeadContext _localctx, int predIndex) { 15500 switch (predIndex) { 15501 case 12: 15502 return !isNextJavadocTag(); 15503 } 15504 return true; 15505 } 15506 private boolean html_sempred(HtmlContext _localctx, int predIndex) { 15507 switch (predIndex) { 15508 case 13: 15509 return !isNextJavadocTag(); 15510 } 15511 return true; 15512 } 15513 private boolean option_sempred(OptionContext _localctx, int predIndex) { 15514 switch (predIndex) { 15515 case 14: 15516 return !isNextJavadocTag(); 15517 } 15518 return true; 15519 } 15520 private boolean tbody_sempred(TbodyContext _localctx, int predIndex) { 15521 switch (predIndex) { 15522 case 15: 15523 return !isNextJavadocTag(); 15524 } 15525 return true; 15526 } 15527 private boolean tfoot_sempred(TfootContext _localctx, int predIndex) { 15528 switch (predIndex) { 15529 case 16: 15530 return !isNextJavadocTag(); 15531 } 15532 return true; 15533 } 15534 private boolean thead_sempred(TheadContext _localctx, int predIndex) { 15535 switch (predIndex) { 15536 case 17: 15537 return !isNextJavadocTag(); 15538 } 15539 return true; 15540 } 15541 private boolean description_sempred(DescriptionContext _localctx, int predIndex) { 15542 switch (predIndex) { 15543 case 18: 15544 return !isNextJavadocTag(); 15545 } 15546 return true; 15547 } 15548 15549 public static final String _serializedATN = 15550 "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3]\u0771\4\2\t\2\4"+ 15551 "\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"+ 15552 "\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"+ 15553 "\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"+ 15554 "\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!"+ 15555 "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ 15556 ",\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"+ 15557 "\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="+ 15558 "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ 15559 "\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"+ 15560 "\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"+ 15561 "\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"+ 15562 "\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"+ 15563 "\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"+ 15564 "\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"+ 15565 "\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"+ 15566 "\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"+ 15567 "\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"+ 15568 "\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"+ 15569 "\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"+ 15570 "\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"+ 15571 "\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"+ 15572 "\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"+ 15573 "\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"+ 15574 "\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"+ 15575 "\13\3\13\3\13\3\13\3\13\3\13\7\13\u0180\n\13\f\13\16\13\u0183\13\13\3"+ 15576 "\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"+ 15577 "\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"+ 15578 "\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"+ 15579 "\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"+ 15580 "\3\16\3\16\7\16\u01c5\n\16\f\16\16\16\u01c8\13\16\3\16\3\16\3\17\3\17"+ 15581 "\3\17\3\17\7\17\u01d0\n\17\f\17\16\17\u01d3\13\17\3\17\3\17\3\20\3\20"+ 15582 "\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"+ 15583 "\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"+ 15584 "\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"+ 15585 "\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"+ 15586 "\21\u020d\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0215\n\22\f\22\16"+ 15587 "\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"+ 15588 "\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"+ 15589 "\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"+ 15590 "\3\23\7\23\u0242\n\23\f\23\16\23\u0245\13\23\3\23\3\23\3\24\3\24\3\24"+ 15591 "\3\24\3\24\3\24\7\24\u024f\n\24\f\24\16\24\u0252\13\24\3\24\3\24\3\25"+ 15592 "\3\25\3\25\3\25\7\25\u025a\n\25\f\25\16\25\u025d\13\25\3\25\3\25\3\26"+ 15593 "\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"+ 15594 "\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"+ 15595 "\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"+ 15596 "\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"+ 15597 "\f\27\16\27\u0297\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u029f\n\30"+ 15598 "\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"+ 15599 "\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"+ 15600 "\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"+ 15601 "\31\3\31\3\31\7\31\u02cc\n\31\f\31\16\31\u02cf\13\31\3\31\3\31\3\32\3"+ 15602 "\32\3\32\3\32\3\32\3\32\7\32\u02d9\n\32\f\32\16\32\u02dc\13\32\3\32\3"+ 15603 "\32\3\33\3\33\3\33\3\33\7\33\u02e4\n\33\f\33\16\33\u02e7\13\33\3\33\3"+ 15604 "\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"+ 15605 "\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"+ 15606 "\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"+ 15607 "\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"+ 15608 "\n\35\f\35\16\35\u0321\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0329"+ 15609 "\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"+ 15610 "\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"+ 15611 "\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"+ 15612 "\37\3\37\3\37\3\37\7\37\u0356\n\37\f\37\16\37\u0359\13\37\3\37\3\37\3"+ 15613 " \3 \3 \3 \3 \3 \7 \u0363\n \f \16 \u0366\13 \3 \3 \3!\3!\3!\3!\7!\u036e"+ 15614 "\n!\f!\16!\u0371\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+ 15615 "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+ 15616 "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u039b\n\"\f\"\16\"\u039e\13"+ 15617 "\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u03a8\n#\f#\16#\u03ab\13#\3#\3#\3$\3$"+ 15618 "\3$\3$\7$\u03b3\n$\f$\16$\u03b6\13$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 15619 "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 15620 "%\3%\3%\3%\3%\3%\7%\u03e0\n%\f%\16%\u03e3\13%\3%\3%\3&\3&\3&\3&\3&\3&"+ 15621 "\7&\u03ed\n&\f&\16&\u03f0\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u03f8\n\'\f\'"+ 15622 "\16\'\u03fb\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+ 15623 "\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+ 15624 "\7(\u0425\n(\f(\16(\u0428\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u0432\n)\f)\16"+ 15625 ")\u0435\13)\3)\3)\3*\3*\3*\3*\7*\u043d\n*\f*\16*\u0440\13*\3*\3*\3+\3"+ 15626 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3"+ 15627 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\7+\u046a\n+\f+\16+\u046d\13+"+ 15628 "\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0477\n,\f,\16,\u047a\13,\3,\3,\3-\3-\3-\3"+ 15629 "-\7-\u0482\n-\f-\16-\u0485\13-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+ 15630 "\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+ 15631 "\3.\3.\3.\3.\7.\u04af\n.\f.\16.\u04b2\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u04bc"+ 15632 "\n/\f/\16/\u04bf\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u04c7\n\60\f\60\16"+ 15633 "\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"+ 15634 "\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"+ 15635 "\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"+ 15636 "\3\61\7\61\u04f4\n\61\f\61\16\61\u04f7\13\61\3\61\3\61\3\62\3\62\3\62"+ 15637 "\3\62\3\62\3\62\7\62\u0501\n\62\f\62\16\62\u0504\13\62\3\62\3\62\3\63"+ 15638 "\3\63\3\63\3\63\7\63\u050c\n\63\f\63\16\63\u050f\13\63\3\63\3\63\3\64"+ 15639 "\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"+ 15640 "\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"+ 15641 "\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"+ 15642 "\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"+ 15643 "\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"+ 15644 "\3\66\7\66\u0557\n\66\f\66\16\66\u055a\13\66\3\66\3\66\3\67\3\67\3\67"+ 15645 "\3\67\3\67\3\67\7\67\u0564\n\67\f\67\16\67\u0567\13\67\3\67\3\67\38\3"+ 15646 "8\38\38\38\38\78\u0571\n8\f8\168\u0574\138\38\38\39\39\39\39\39\39\79"+ 15647 "\u057e\n9\f9\169\u0581\139\39\39\3:\3:\3:\3:\3:\3:\7:\u058b\n:\f:\16:"+ 15648 "\u058e\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0598\n;\f;\16;\u059b\13;\3;\3;"+ 15649 "\3<\3<\3<\3<\3<\3<\7<\u05a5\n<\f<\16<\u05a8\13<\3<\3<\3=\3=\3=\3=\3=\3"+ 15650 "=\7=\u05b2\n=\f=\16=\u05b5\13=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u05bf\n>\f>"+ 15651 "\16>\u05c2\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u05cc\n?\f?\16?\u05cf\13?\3"+ 15652 "?\3?\3@\3@\3@\3@\3@\3@\7@\u05d9\n@\f@\16@\u05dc\13@\3@\3@\3A\3A\3A\3A"+ 15653 "\3A\3A\7A\u05e6\nA\fA\16A\u05e9\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u05f3\n"+ 15654 "B\fB\16B\u05f6\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u0600\nC\fC\16C\u0603\13"+ 15655 "C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u0617\nF\r"+ 15656 "F\16F\u0618\3G\3G\7G\u061d\nG\fG\16G\u0620\13G\3G\5G\u0623\nG\3G\5G\u0626"+ 15657 "\nG\3G\5G\u0629\nG\3G\6G\u062c\nG\rG\16G\u062d\3G\5G\u0631\nG\3G\5G\u0634"+ 15658 "\nG\3G\5G\u0637\nG\3G\5G\u063a\nG\3G\3G\5G\u063e\nG\5G\u0640\nG\3H\3H"+ 15659 "\7H\u0644\nH\fH\16H\u0647\13H\3H\3H\3I\3I\7I\u064d\nI\fI\16I\u0650\13"+ 15660 "I\3I\5I\u0653\nI\3I\3I\7I\u0657\nI\fI\16I\u065a\13I\3I\5I\u065d\nI\3I"+ 15661 "\3I\7I\u0661\nI\fI\16I\u0664\13I\3I\5I\u0667\nI\3I\7I\u066a\nI\fI\16I"+ 15662 "\u066d\13I\3I\5I\u0670\nI\3I\3I\7I\u0674\nI\fI\16I\u0677\13I\3I\5I\u067a"+ 15663 "\nI\3I\7I\u067d\nI\fI\16I\u0680\13I\3I\5I\u0683\nI\3I\3I\7I\u0687\nI\f"+ 15664 "I\16I\u068a\13I\3I\5I\u068d\nI\3I\3I\7I\u0691\nI\fI\16I\u0694\13I\3I\5"+ 15665 "I\u0697\nI\3I\3I\7I\u069b\nI\fI\16I\u069e\13I\3I\7I\u06a1\nI\fI\16I\u06a4"+ 15666 "\13I\3I\5I\u06a7\nI\3I\3I\7I\u06ab\nI\fI\16I\u06ae\13I\3I\5I\u06b1\nI"+ 15667 "\3I\5I\u06b4\nI\3I\3I\7I\u06b8\nI\fI\16I\u06bb\13I\3I\5I\u06be\nI\3I\3"+ 15668 "I\7I\u06c2\nI\fI\16I\u06c5\13I\3I\5I\u06c8\nI\3I\7I\u06cb\nI\fI\16I\u06ce"+ 15669 "\13I\3I\5I\u06d1\nI\3I\7I\u06d4\nI\fI\16I\u06d7\13I\3I\5I\u06da\nI\3I"+ 15670 "\3I\7I\u06de\nI\fI\16I\u06e1\13I\3I\5I\u06e4\nI\3I\3I\7I\u06e8\nI\fI\16"+ 15671 "I\u06eb\13I\3I\5I\u06ee\nI\3I\7I\u06f1\nI\fI\16I\u06f4\13I\3I\5I\u06f7"+ 15672 "\nI\3I\3I\7I\u06fb\nI\fI\16I\u06fe\13I\3I\5I\u0701\nI\3I\3I\7I\u0705\n"+ 15673 "I\fI\16I\u0708\13I\3I\5I\u070b\nI\5I\u070d\nI\3J\3J\3J\3J\3J\3J\7J\u0715"+ 15674 "\nJ\fJ\16J\u0718\13J\3J\3J\7J\u071c\nJ\fJ\16J\u071f\13J\3J\3J\7J\u0723"+ 15675 "\nJ\fJ\16J\u0726\13J\3J\3J\7J\u072a\nJ\fJ\16J\u072d\13J\3J\3J\5J\u0731"+ 15676 "\nJ\3J\3J\7J\u0735\nJ\fJ\16J\u0738\13J\3J\3J\5J\u073c\nJ\3J\3J\3J\3J\3"+ 15677 "J\7J\u0743\nJ\fJ\16J\u0746\13J\3J\3J\7J\u074a\nJ\fJ\16J\u074d\13J\3J\5"+ 15678 "J\u0750\nJ\3J\3J\7J\u0754\nJ\fJ\16J\u0757\13J\3J\5J\u075a\nJ\5J\u075c"+ 15679 "\nJ\3J\3J\3K\3K\3K\3K\7K\u0764\nK\fK\16K\u0767\13K\3K\3K\3L\3L\6L\u076d"+ 15680 "\nL\rL\16L\u076e\3L\2\2M\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&("+ 15681 "*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084"+ 15682 "\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\2\13\5\2\3\3\6"+ 15683 "\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"+ 15684 "\3\2\30\31\4\2\6\6\32\32\u0a88\2\u00a2\3\2\2\2\4\u00e5\3\2\2\2\6\u00e7"+ 15685 "\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"+ 15686 "\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"+ 15687 "\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"+ 15688 " \u0203\3\2\2\2\"\u0210\3\2\2\2$\u021b\3\2\2\2&\u0248\3\2\2\2(\u0255\3"+ 15689 "\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"+ 15690 "\u02d2\3\2\2\2\64\u02df\3\2\2\2\66\u02ea\3\2\2\28\u0317\3\2\2\2:\u0324"+ 15691 "\3\2\2\2<\u032f\3\2\2\2>\u035c\3\2\2\2@\u0369\3\2\2\2B\u0374\3\2\2\2D"+ 15692 "\u03a1\3\2\2\2F\u03ae\3\2\2\2H\u03b9\3\2\2\2J\u03e6\3\2\2\2L\u03f3\3\2"+ 15693 "\2\2N\u03fe\3\2\2\2P\u042b\3\2\2\2R\u0438\3\2\2\2T\u0443\3\2\2\2V\u0470"+ 15694 "\3\2\2\2X\u047d\3\2\2\2Z\u0488\3\2\2\2\\\u04b5\3\2\2\2^\u04c2\3\2\2\2"+ 15695 "`\u04cd\3\2\2\2b\u04fa\3\2\2\2d\u0507\3\2\2\2f\u0512\3\2\2\2h\u054e\3"+ 15696 "\2\2\2j\u0550\3\2\2\2l\u055d\3\2\2\2n\u056a\3\2\2\2p\u0577\3\2\2\2r\u0584"+ 15697 "\3\2\2\2t\u0591\3\2\2\2v\u059e\3\2\2\2x\u05ab\3\2\2\2z\u05b8\3\2\2\2|"+ 15698 "\u05c5\3\2\2\2~\u05d2\3\2\2\2\u0080\u05df\3\2\2\2\u0082\u05ec\3\2\2\2"+ 15699 "\u0084\u05f9\3\2\2\2\u0086\u0606\3\2\2\2\u0088\u060c\3\2\2\2\u008a\u0616"+ 15700 "\3\2\2\2\u008c\u063f\3\2\2\2\u008e\u0641\3\2\2\2\u0090\u070c\3\2\2\2\u0092"+ 15701 "\u070e\3\2\2\2\u0094\u075f\3\2\2\2\u0096\u076c\3\2\2\2\u0098\u00a1\5\4"+ 15702 "\3\2\u0099\u009a\6\2\2\2\u009a\u00a1\7\3\2\2\u009b\u00a1\5\u0094K\2\u009c"+ 15703 "\u00a1\7\5\2\2\u009d\u00a1\7\b\2\2\u009e\u00a1\5\u0096L\2\u009f\u00a1"+ 15704 "\5\u0092J\2\u00a0\u0098\3\2\2\2\u00a0\u0099\3\2\2\2\u00a0\u009b\3\2\2"+ 15705 "\2\u00a0\u009c\3\2\2\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u009f"+ 15706 "\3\2\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3"+ 15707 "\u00b1\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a7\7\3\2\2\u00a6\u00a5\3\2"+ 15708 "\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00ab\3\2\2\2\u00a8\u00aa\7\6\2\2\u00a9"+ 15709 "\u00a8\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2"+ 15710 "\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00b0\5\u0090I\2\u00af"+ 15711 "\u00a6\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2"+ 15712 "\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5\7\2\2\3\u00b5"+ 15713 "\3\3\2\2\2\u00b6\u00e6\5\f\7\2\u00b7\u00e6\5h\65\2\u00b8\u00e6\5\22\n"+ 15714 "\2\u00b9\u00e6\5\30\r\2\u00ba\u00e6\5\36\20\2\u00bb\u00e6\5$\23\2\u00bc"+ 15715 "\u00e6\5*\26\2\u00bd\u00e6\5\60\31\2\u00be\u00e6\5\66\34\2\u00bf\u00e6"+ 15716 "\5<\37\2\u00c0\u00e6\5B\"\2\u00c1\u00e6\5H%\2\u00c2\u00e6\5N(\2\u00c3"+ 15717 "\u00e6\5T+\2\u00c4\u00e6\5Z.\2\u00c5\u00e6\5f\64\2\u00c6\u00e6\5`\61\2"+ 15718 "\u00c7\u00e6\5\16\b\2\u00c8\u00e6\5\24\13\2\u00c9\u00e6\5\32\16\2\u00ca"+ 15719 "\u00e6\5 \21\2\u00cb\u00e6\5&\24\2\u00cc\u00e6\5,\27\2\u00cd\u00e6\5\62"+ 15720 "\32\2\u00ce\u00e6\58\35\2\u00cf\u00e6\5> \2\u00d0\u00e6\5D#\2\u00d1\u00e6"+ 15721 "\5J&\2\u00d2\u00e6\5P)\2\u00d3\u00e6\5V,\2\u00d4\u00e6\5b\62\2\u00d5\u00e6"+ 15722 "\5\\/\2\u00d6\u00e6\5\20\t\2\u00d7\u00e6\5\26\f\2\u00d8\u00e6\5\34\17"+ 15723 "\2\u00d9\u00e6\5\"\22\2\u00da\u00e6\5(\25\2\u00db\u00e6\5.\30\2\u00dc"+ 15724 "\u00e6\5\64\33\2\u00dd\u00e6\5:\36\2\u00de\u00e6\5@!\2\u00df\u00e6\5F"+ 15725 "$\2\u00e0\u00e6\5L\'\2\u00e1\u00e6\5R*\2\u00e2\u00e6\5X-\2\u00e3\u00e6"+ 15726 "\5d\63\2\u00e4\u00e6\5^\60\2\u00e5\u00b6\3\2\2\2\u00e5\u00b7\3\2\2\2\u00e5"+ 15727 "\u00b8\3\2\2\2\u00e5\u00b9\3\2\2\2\u00e5\u00ba\3\2\2\2\u00e5\u00bb\3\2"+ 15728 "\2\2\u00e5\u00bc\3\2\2\2\u00e5\u00bd\3\2\2\2\u00e5\u00be\3\2\2\2\u00e5"+ 15729 "\u00bf\3\2\2\2\u00e5\u00c0\3\2\2\2\u00e5\u00c1\3\2\2\2\u00e5\u00c2\3\2"+ 15730 "\2\2\u00e5\u00c3\3\2\2\2\u00e5\u00c4\3\2\2\2\u00e5\u00c5\3\2\2\2\u00e5"+ 15731 "\u00c6\3\2\2\2\u00e5\u00c7\3\2\2\2\u00e5\u00c8\3\2\2\2\u00e5\u00c9\3\2"+ 15732 "\2\2\u00e5\u00ca\3\2\2\2\u00e5\u00cb\3\2\2\2\u00e5\u00cc\3\2\2\2\u00e5"+ 15733 "\u00cd\3\2\2\2\u00e5\u00ce\3\2\2\2\u00e5\u00cf\3\2\2\2\u00e5\u00d0\3\2"+ 15734 "\2\2\u00e5\u00d1\3\2\2\2\u00e5\u00d2\3\2\2\2\u00e5\u00d3\3\2\2\2\u00e5"+ 15735 "\u00d4\3\2\2\2\u00e5\u00d5\3\2\2\2\u00e5\u00d6\3\2\2\2\u00e5\u00d7\3\2"+ 15736 "\2\2\u00e5\u00d8\3\2\2\2\u00e5\u00d9\3\2\2\2\u00e5\u00da\3\2\2\2\u00e5"+ 15737 "\u00db\3\2\2\2\u00e5\u00dc\3\2\2\2\u00e5\u00dd\3\2\2\2\u00e5\u00de\3\2"+ 15738 "\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2\u00e5\u00e1\3\2\2\2\u00e5"+ 15739 "\u00e2\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4\3\2\2\2\u00e6\5\3\2\2\2"+ 15740 "\u00e7\u00e8\7\7\2\2\u00e8\u00ef\7Y\2\2\u00e9\u00ee\5\n\6\2\u00ea\u00ee"+ 15741 "\7\b\2\2\u00eb\u00ee\7\3\2\2\u00ec\u00ee\7\6\2\2\u00ed\u00e9\3\2\2\2\u00ed"+ 15742 "\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec\3\2\2\2\u00ee\u00f1\3\2"+ 15743 "\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\3\2\2\2\u00f1"+ 15744 "\u00ef\3\2\2\2\u00f2\u00f3\79\2\2\u00f3\7\3\2\2\2\u00f4\u00f5\7\7\2\2"+ 15745 "\u00f5\u00f6\7;\2\2\u00f6\u00fa\7Y\2\2\u00f7\u00f9\t\2\2\2\u00f8\u00f7"+ 15746 "\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb"+ 15747 "\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\79\2\2\u00fe\t\3\2\2\2"+ 15748 "\u00ff\u0103\7Y\2\2\u0100\u0102\t\2\2\2\u0101\u0100\3\2\2\2\u0102\u0105"+ 15749 "\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105"+ 15750 "\u0103\3\2\2\2\u0106\u010a\7<\2\2\u0107\u0109\t\2\2\2\u0108\u0107\3\2"+ 15751 "\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b"+ 15752 "\u0110\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0111\7[\2\2\u010e\u0111\5\u0096"+ 15753 "L\2\u010f\u0111\7Y\2\2\u0110\u010d\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u010f"+ 15754 "\3\2\2\2\u0111\13\3\2\2\2\u0112\u011d\5\6\4\2\u0113\u011c\5\4\3\2\u0114"+ 15755 "\u0115\6\7\3\2\u0115\u011c\7\3\2\2\u0116\u011c\5\u0094K\2\u0117\u011c"+ 15756 "\7\5\2\2\u0118\u011c\7\b\2\2\u0119\u011c\5\u0096L\2\u011a\u011c\5\u0092"+ 15757 "J\2\u011b\u0113\3\2\2\2\u011b\u0114\3\2\2\2\u011b\u0116\3\2\2\2\u011b"+ 15758 "\u0117\3\2\2\2\u011b\u0118\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2"+ 15759 "\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+ 15760 "\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\5\b\5\2\u0121\u0133\3\2"+ 15761 "\2\2\u0122\u012d\5\6\4\2\u0123\u012c\5\4\3\2\u0124\u0125\6\7\4\2\u0125"+ 15762 "\u012c\7\3\2\2\u0126\u012c\5\u0094K\2\u0127\u012c\7\5\2\2\u0128\u012c"+ 15763 "\7\b\2\2\u0129\u012c\5\u0096L\2\u012a\u012c\5\u0092J\2\u012b\u0123\3\2"+ 15764 "\2\2\u012b\u0124\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012b"+ 15765 "\u0128\3\2\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f\3\2"+ 15766 "\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0130\3\2\2\2\u012f"+ 15767 "\u012d\3\2\2\2\u0130\u0131\b\7\1\2\u0131\u0133\3\2\2\2\u0132\u0112\3\2"+ 15768 "\2\2\u0132\u0122\3\2\2\2\u0133\r\3\2\2\2\u0134\u0135\7\7\2\2\u0135\u013c"+ 15769 "\7=\2\2\u0136\u013b\5\n\6\2\u0137\u013b\7\b\2\2\u0138\u013b\7\3\2\2\u0139"+ 15770 "\u013b\7\6\2\2\u013a\u0136\3\2\2\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2"+ 15771 "\2\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+ 15772 "\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0140\79"+ 15773 "\2\2\u0140\17\3\2\2\2\u0141\u0142\7\7\2\2\u0142\u0143\7;\2\2\u0143\u0147"+ 15774 "\7=\2\2\u0144\u0146\t\2\2\2\u0145\u0144\3\2\2\2\u0146\u0149\3\2\2\2\u0147"+ 15775 "\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2\u0149\u0147\3\2"+ 15776 "\2\2\u014a\u014b\79\2\2\u014b\21\3\2\2\2\u014c\u0174\5\16\b\2\u014d\u0173"+ 15777 "\5\f\7\2\u014e\u0173\5j\66\2\u014f\u0173\5\30\r\2\u0150\u0173\5\36\20"+ 15778 "\2\u0151\u0173\5$\23\2\u0152\u0173\5*\26\2\u0153\u0173\5\60\31\2\u0154"+ 15779 "\u0173\5\66\34\2\u0155\u0173\5<\37\2\u0156\u0173\5B\"\2\u0157\u0173\5"+ 15780 "H%\2\u0158\u0173\5N(\2\u0159\u0173\5T+\2\u015a\u0173\5Z.\2\u015b\u0173"+ 15781 "\5f\64\2\u015c\u0173\5`\61\2\u015d\u0173\5\24\13\2\u015e\u0173\5\32\16"+ 15782 "\2\u015f\u0173\5 \21\2\u0160\u0173\5&\24\2\u0161\u0173\5,\27\2\u0162\u0173"+ 15783 "\5\62\32\2\u0163\u0173\58\35\2\u0164\u0173\5> \2\u0165\u0173\5D#\2\u0166"+ 15784 "\u0173\5J&\2\u0167\u0173\5P)\2\u0168\u0173\5V,\2\u0169\u0173\5b\62\2\u016a"+ 15785 "\u0173\5\\/\2\u016b\u016c\6\n\5\2\u016c\u0173\7\3\2\2\u016d\u0173\5\u0094"+ 15786 "K\2\u016e\u0173\7\5\2\2\u016f\u0173\7\b\2\2\u0170\u0173\5\u0096L\2\u0171"+ 15787 "\u0173\5\u0092J\2\u0172\u014d\3\2\2\2\u0172\u014e\3\2\2\2\u0172\u014f"+ 15788 "\3\2\2\2\u0172\u0150\3\2\2\2\u0172\u0151\3\2\2\2\u0172\u0152\3\2\2\2\u0172"+ 15789 "\u0153\3\2\2\2\u0172\u0154\3\2\2\2\u0172\u0155\3\2\2\2\u0172\u0156\3\2"+ 15790 "\2\2\u0172\u0157\3\2\2\2\u0172\u0158\3\2\2\2\u0172\u0159\3\2\2\2\u0172"+ 15791 "\u015a\3\2\2\2\u0172\u015b\3\2\2\2\u0172\u015c\3\2\2\2\u0172\u015d\3\2"+ 15792 "\2\2\u0172\u015e\3\2\2\2\u0172\u015f\3\2\2\2\u0172\u0160\3\2\2\2\u0172"+ 15793 "\u0161\3\2\2\2\u0172\u0162\3\2\2\2\u0172\u0163\3\2\2\2\u0172\u0164\3\2"+ 15794 "\2\2\u0172\u0165\3\2\2\2\u0172\u0166\3\2\2\2\u0172\u0167\3\2\2\2\u0172"+ 15795 "\u0168\3\2\2\2\u0172\u0169\3\2\2\2\u0172\u016a\3\2\2\2\u0172\u016b\3\2"+ 15796 "\2\2\u0172\u016d\3\2\2\2\u0172\u016e\3\2\2\2\u0172\u016f\3\2\2\2\u0172"+ 15797 "\u0170\3\2\2\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2"+ 15798 "\2\2\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177"+ 15799 "\u0178\5\20\t\2\u0178\23\3\2\2\2\u0179\u017a\7\7\2\2\u017a\u0181\7>\2"+ 15800 "\2\u017b\u0180\5\n\6\2\u017c\u0180\7\b\2\2\u017d\u0180\7\3\2\2\u017e\u0180"+ 15801 "\7\6\2\2\u017f\u017b\3\2\2\2\u017f\u017c\3\2\2\2\u017f\u017d\3\2\2\2\u017f"+ 15802 "\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+ 15803 "\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\79\2\2\u0185"+ 15804 "\25\3\2\2\2\u0186\u0187\7\7\2\2\u0187\u0188\7;\2\2\u0188\u018c\7>\2\2"+ 15805 "\u0189\u018b\t\2\2\2\u018a\u0189\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a"+ 15806 "\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f"+ 15807 "\u0190\79\2\2\u0190\27\3\2\2\2\u0191\u01b9\5\24\13\2\u0192\u01b8\5\f\7"+ 15808 "\2\u0193\u01b8\5j\66\2\u0194\u01b8\5\22\n\2\u0195\u01b8\5\36\20\2\u0196"+ 15809 "\u01b8\5$\23\2\u0197\u01b8\5*\26\2\u0198\u01b8\5\60\31\2\u0199\u01b8\5"+ 15810 "\66\34\2\u019a\u01b8\5<\37\2\u019b\u01b8\5B\"\2\u019c\u01b8\5H%\2\u019d"+ 15811 "\u01b8\5N(\2\u019e\u01b8\5T+\2\u019f\u01b8\5Z.\2\u01a0\u01b8\5f\64\2\u01a1"+ 15812 "\u01b8\5`\61\2\u01a2\u01b8\5\16\b\2\u01a3\u01b8\5\32\16\2\u01a4\u01b8"+ 15813 "\5 \21\2\u01a5\u01b8\5&\24\2\u01a6\u01b8\5,\27\2\u01a7\u01b8\5\62\32\2"+ 15814 "\u01a8\u01b8\58\35\2\u01a9\u01b8\5> \2\u01aa\u01b8\5D#\2\u01ab\u01b8\5"+ 15815 "J&\2\u01ac\u01b8\5P)\2\u01ad\u01b8\5V,\2\u01ae\u01b8\5b\62\2\u01af\u01b8"+ 15816 "\5\\/\2\u01b0\u01b1\6\r\6\2\u01b1\u01b8\7\3\2\2\u01b2\u01b8\5\u0094K\2"+ 15817 "\u01b3\u01b8\7\5\2\2\u01b4\u01b8\7\b\2\2\u01b5\u01b8\5\u0096L\2\u01b6"+ 15818 "\u01b8\5\u0092J\2\u01b7\u0192\3\2\2\2\u01b7\u0193\3\2\2\2\u01b7\u0194"+ 15819 "\3\2\2\2\u01b7\u0195\3\2\2\2\u01b7\u0196\3\2\2\2\u01b7\u0197\3\2\2\2\u01b7"+ 15820 "\u0198\3\2\2\2\u01b7\u0199\3\2\2\2\u01b7\u019a\3\2\2\2\u01b7\u019b\3\2"+ 15821 "\2\2\u01b7\u019c\3\2\2\2\u01b7\u019d\3\2\2\2\u01b7\u019e\3\2\2\2\u01b7"+ 15822 "\u019f\3\2\2\2\u01b7\u01a0\3\2\2\2\u01b7\u01a1\3\2\2\2\u01b7\u01a2\3\2"+ 15823 "\2\2\u01b7\u01a3\3\2\2\2\u01b7\u01a4\3\2\2\2\u01b7\u01a5\3\2\2\2\u01b7"+ 15824 "\u01a6\3\2\2\2\u01b7\u01a7\3\2\2\2\u01b7\u01a8\3\2\2\2\u01b7\u01a9\3\2"+ 15825 "\2\2\u01b7\u01aa\3\2\2\2\u01b7\u01ab\3\2\2\2\u01b7\u01ac\3\2\2\2\u01b7"+ 15826 "\u01ad\3\2\2\2\u01b7\u01ae\3\2\2\2\u01b7\u01af\3\2\2\2\u01b7\u01b0\3\2"+ 15827 "\2\2\u01b7\u01b2\3\2\2\2\u01b7\u01b3\3\2\2\2\u01b7\u01b4\3\2\2\2\u01b7"+ 15828 "\u01b5\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2"+ 15829 "\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc"+ 15830 "\u01bd\5\26\f\2\u01bd\31\3\2\2\2\u01be\u01bf\7\7\2\2\u01bf\u01c6\7?\2"+ 15831 "\2\u01c0\u01c5\5\n\6\2\u01c1\u01c5\7\b\2\2\u01c2\u01c5\7\3\2\2\u01c3\u01c5"+ 15832 "\7\6\2\2\u01c4\u01c0\3\2\2\2\u01c4\u01c1\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c4"+ 15833 "\u01c3\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2"+ 15834 "\2\2\u01c7\u01c9\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\79\2\2\u01ca"+ 15835 "\33\3\2\2\2\u01cb\u01cc\7\7\2\2\u01cc\u01cd\7;\2\2\u01cd\u01d1\7?\2\2"+ 15836 "\u01ce\u01d0\t\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+ 15837 "\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d4\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+ 15838 "\u01d5\79\2\2\u01d5\35\3\2\2\2\u01d6\u01fe\5\32\16\2\u01d7\u01fd\5\f\7"+ 15839 "\2\u01d8\u01fd\5j\66\2\u01d9\u01fd\5\22\n\2\u01da\u01fd\5\30\r\2\u01db"+ 15840 "\u01fd\5$\23\2\u01dc\u01fd\5*\26\2\u01dd\u01fd\5\60\31\2\u01de\u01fd\5"+ 15841 "\66\34\2\u01df\u01fd\5<\37\2\u01e0\u01fd\5B\"\2\u01e1\u01fd\5H%\2\u01e2"+ 15842 "\u01fd\5N(\2\u01e3\u01fd\5T+\2\u01e4\u01fd\5Z.\2\u01e5\u01fd\5f\64\2\u01e6"+ 15843 "\u01fd\5`\61\2\u01e7\u01fd\5\16\b\2\u01e8\u01fd\5\24\13\2\u01e9\u01fd"+ 15844 "\5 \21\2\u01ea\u01fd\5&\24\2\u01eb\u01fd\5,\27\2\u01ec\u01fd\5\62\32\2"+ 15845 "\u01ed\u01fd\58\35\2\u01ee\u01fd\5> \2\u01ef\u01fd\5D#\2\u01f0\u01fd\5"+ 15846 "J&\2\u01f1\u01fd\5P)\2\u01f2\u01fd\5V,\2\u01f3\u01fd\5b\62\2\u01f4\u01fd"+ 15847 "\5\\/\2\u01f5\u01f6\6\20\7\2\u01f6\u01fd\7\3\2\2\u01f7\u01fd\5\u0094K"+ 15848 "\2\u01f8\u01fd\7\5\2\2\u01f9\u01fd\7\b\2\2\u01fa\u01fd\5\u0096L\2\u01fb"+ 15849 "\u01fd\5\u0092J\2\u01fc\u01d7\3\2\2\2\u01fc\u01d8\3\2\2\2\u01fc\u01d9"+ 15850 "\3\2\2\2\u01fc\u01da\3\2\2\2\u01fc\u01db\3\2\2\2\u01fc\u01dc\3\2\2\2\u01fc"+ 15851 "\u01dd\3\2\2\2\u01fc\u01de\3\2\2\2\u01fc\u01df\3\2\2\2\u01fc\u01e0\3\2"+ 15852 "\2\2\u01fc\u01e1\3\2\2\2\u01fc\u01e2\3\2\2\2\u01fc\u01e3\3\2\2\2\u01fc"+ 15853 "\u01e4\3\2\2\2\u01fc\u01e5\3\2\2\2\u01fc\u01e6\3\2\2\2\u01fc\u01e7\3\2"+ 15854 "\2\2\u01fc\u01e8\3\2\2\2\u01fc\u01e9\3\2\2\2\u01fc\u01ea\3\2\2\2\u01fc"+ 15855 "\u01eb\3\2\2\2\u01fc\u01ec\3\2\2\2\u01fc\u01ed\3\2\2\2\u01fc\u01ee\3\2"+ 15856 "\2\2\u01fc\u01ef\3\2\2\2\u01fc\u01f0\3\2\2\2\u01fc\u01f1\3\2\2\2\u01fc"+ 15857 "\u01f2\3\2\2\2\u01fc\u01f3\3\2\2\2\u01fc\u01f4\3\2\2\2\u01fc\u01f5\3\2"+ 15858 "\2\2\u01fc\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc"+ 15859 "\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2"+ 15860 "\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201\3\2\2\2\u0200\u01fe\3\2\2\2\u0201"+ 15861 "\u0202\5\34\17\2\u0202\37\3\2\2\2\u0203\u0204\7\7\2\2\u0204\u020b\7@\2"+ 15862 "\2\u0205\u020a\5\n\6\2\u0206\u020a\7\b\2\2\u0207\u020a\7\3\2\2\u0208\u020a"+ 15863 "\7\6\2\2\u0209\u0205\3\2\2\2\u0209\u0206\3\2\2\2\u0209\u0207\3\2\2\2\u0209"+ 15864 "\u0208\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2"+ 15865 "\2\2\u020c\u020e\3\2\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f"+ 15866 "!\3\2\2\2\u0210\u0211\7\7\2\2\u0211\u0212\7;\2\2\u0212\u0216\7@\2\2\u0213"+ 15867 "\u0215\t\2\2\2\u0214\u0213\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2"+ 15868 "\2\2\u0216\u0217\3\2\2\2\u0217\u0219\3\2\2\2\u0218\u0216\3\2\2\2\u0219"+ 15869 "\u021a\79\2\2\u021a#\3\2\2\2\u021b\u0243\5 \21\2\u021c\u0242\5\f\7\2\u021d"+ 15870 "\u0242\5j\66\2\u021e\u0242\5\22\n\2\u021f\u0242\5\30\r\2\u0220\u0242\5"+ 15871 "\36\20\2\u0221\u0242\5*\26\2\u0222\u0242\5\60\31\2\u0223\u0242\5\66\34"+ 15872 "\2\u0224\u0242\5<\37\2\u0225\u0242\5B\"\2\u0226\u0242\5H%\2\u0227\u0242"+ 15873 "\5N(\2\u0228\u0242\5T+\2\u0229\u0242\5Z.\2\u022a\u0242\5f\64\2\u022b\u0242"+ 15874 "\5`\61\2\u022c\u0242\5\16\b\2\u022d\u0242\5\24\13\2\u022e\u0242\5 \21"+ 15875 "\2\u022f\u0242\5&\24\2\u0230\u0242\5,\27\2\u0231\u0242\5\62\32\2\u0232"+ 15876 "\u0242\58\35\2\u0233\u0242\5> \2\u0234\u0242\5D#\2\u0235\u0242\5J&\2\u0236"+ 15877 "\u0242\5P)\2\u0237\u0242\5V,\2\u0238\u0242\5b\62\2\u0239\u0242\5\\/\2"+ 15878 "\u023a\u023b\6\23\b\2\u023b\u0242\7\3\2\2\u023c\u0242\5\u0094K\2\u023d"+ 15879 "\u0242\7\5\2\2\u023e\u0242\7\b\2\2\u023f\u0242\5\u0096L\2\u0240\u0242"+ 15880 "\5\u0092J\2\u0241\u021c\3\2\2\2\u0241\u021d\3\2\2\2\u0241\u021e\3\2\2"+ 15881 "\2\u0241\u021f\3\2\2\2\u0241\u0220\3\2\2\2\u0241\u0221\3\2\2\2\u0241\u0222"+ 15882 "\3\2\2\2\u0241\u0223\3\2\2\2\u0241\u0224\3\2\2\2\u0241\u0225\3\2\2\2\u0241"+ 15883 "\u0226\3\2\2\2\u0241\u0227\3\2\2\2\u0241\u0228\3\2\2\2\u0241\u0229\3\2"+ 15884 "\2\2\u0241\u022a\3\2\2\2\u0241\u022b\3\2\2\2\u0241\u022c\3\2\2\2\u0241"+ 15885 "\u022d\3\2\2\2\u0241\u022e\3\2\2\2\u0241\u022f\3\2\2\2\u0241\u0230\3\2"+ 15886 "\2\2\u0241\u0231\3\2\2\2\u0241\u0232\3\2\2\2\u0241\u0233\3\2\2\2\u0241"+ 15887 "\u0234\3\2\2\2\u0241\u0235\3\2\2\2\u0241\u0236\3\2\2\2\u0241\u0237\3\2"+ 15888 "\2\2\u0241\u0238\3\2\2\2\u0241\u0239\3\2\2\2\u0241\u023a\3\2\2\2\u0241"+ 15889 "\u023c\3\2\2\2\u0241\u023d\3\2\2\2\u0241\u023e\3\2\2\2\u0241\u023f\3\2"+ 15890 "\2\2\u0241\u0240\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243"+ 15891 "\u0244\3\2\2\2\u0244\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\5\""+ 15892 "\22\2\u0247%\3\2\2\2\u0248\u0249\7\7\2\2\u0249\u0250\7A\2\2\u024a\u024f"+ 15893 "\5\n\6\2\u024b\u024f\7\b\2\2\u024c\u024f\7\3\2\2\u024d\u024f\7\6\2\2\u024e"+ 15894 "\u024a\3\2\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2"+ 15895 "\2\2\u024f\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251"+ 15896 "\u0253\3\2\2\2\u0252\u0250\3\2\2\2\u0253\u0254\79\2\2\u0254\'\3\2\2\2"+ 15897 "\u0255\u0256\7\7\2\2\u0256\u0257\7;\2\2\u0257\u025b\7A\2\2\u0258\u025a"+ 15898 "\t\2\2\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b"+ 15899 "\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f\79"+ 15900 "\2\2\u025f)\3\2\2\2\u0260\u0288\5&\24\2\u0261\u0287\5\f\7\2\u0262\u0287"+ 15901 "\5j\66\2\u0263\u0287\5\22\n\2\u0264\u0287\5\30\r\2\u0265\u0287\5\36\20"+ 15902 "\2\u0266\u0287\5$\23\2\u0267\u0287\5\60\31\2\u0268\u0287\5\66\34\2\u0269"+ 15903 "\u0287\5<\37\2\u026a\u0287\5B\"\2\u026b\u0287\5H%\2\u026c\u0287\5N(\2"+ 15904 "\u026d\u0287\5T+\2\u026e\u0287\5Z.\2\u026f\u0287\5f\64\2\u0270\u0287\5"+ 15905 "`\61\2\u0271\u0287\5\16\b\2\u0272\u0287\5\24\13\2\u0273\u0287\5\32\16"+ 15906 "\2\u0274\u0287\5 \21\2\u0275\u0287\5,\27\2\u0276\u0287\5\62\32\2\u0277"+ 15907 "\u0287\58\35\2\u0278\u0287\5> \2\u0279\u0287\5D#\2\u027a\u0287\5J&\2\u027b"+ 15908 "\u0287\5P)\2\u027c\u0287\5V,\2\u027d\u0287\5b\62\2\u027e\u0287\5\\/\2"+ 15909 "\u027f\u0280\6\26\t\2\u0280\u0287\7\3\2\2\u0281\u0287\5\u0094K\2\u0282"+ 15910 "\u0287\7\5\2\2\u0283\u0287\7\b\2\2\u0284\u0287\5\u0096L\2\u0285\u0287"+ 15911 "\5\u0092J\2\u0286\u0261\3\2\2\2\u0286\u0262\3\2\2\2\u0286\u0263\3\2\2"+ 15912 "\2\u0286\u0264\3\2\2\2\u0286\u0265\3\2\2\2\u0286\u0266\3\2\2\2\u0286\u0267"+ 15913 "\3\2\2\2\u0286\u0268\3\2\2\2\u0286\u0269\3\2\2\2\u0286\u026a\3\2\2\2\u0286"+ 15914 "\u026b\3\2\2\2\u0286\u026c\3\2\2\2\u0286\u026d\3\2\2\2\u0286\u026e\3\2"+ 15915 "\2\2\u0286\u026f\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0271\3\2\2\2\u0286"+ 15916 "\u0272\3\2\2\2\u0286\u0273\3\2\2\2\u0286\u0274\3\2\2\2\u0286\u0275\3\2"+ 15917 "\2\2\u0286\u0276\3\2\2\2\u0286\u0277\3\2\2\2\u0286\u0278\3\2\2\2\u0286"+ 15918 "\u0279\3\2\2\2\u0286\u027a\3\2\2\2\u0286\u027b\3\2\2\2\u0286\u027c\3\2"+ 15919 "\2\2\u0286\u027d\3\2\2\2\u0286\u027e\3\2\2\2\u0286\u027f\3\2\2\2\u0286"+ 15920 "\u0281\3\2\2\2\u0286\u0282\3\2\2\2\u0286\u0283\3\2\2\2\u0286\u0284\3\2"+ 15921 "\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+ 15922 "\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\5("+ 15923 "\25\2\u028c+\3\2\2\2\u028d\u028e\7\7\2\2\u028e\u0295\7B\2\2\u028f\u0294"+ 15924 "\5\n\6\2\u0290\u0294\7\b\2\2\u0291\u0294\7\3\2\2\u0292\u0294\7\6\2\2\u0293"+ 15925 "\u028f\3\2\2\2\u0293\u0290\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0292\3\2"+ 15926 "\2\2\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296"+ 15927 "\u0298\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0299\79\2\2\u0299-\3\2\2\2\u029a"+ 15928 "\u029b\7\7\2\2\u029b\u029c\7;\2\2\u029c\u02a0\7B\2\2\u029d\u029f\t\2\2"+ 15929 "\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e\3\2\2\2\u02a0\u02a1"+ 15930 "\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a3\u02a4\79\2\2\u02a4"+ 15931 "/\3\2\2\2\u02a5\u02cd\5,\27\2\u02a6\u02cc\5\f\7\2\u02a7\u02cc\5j\66\2"+ 15932 "\u02a8\u02cc\5\22\n\2\u02a9\u02cc\5\30\r\2\u02aa\u02cc\5\36\20\2\u02ab"+ 15933 "\u02cc\5$\23\2\u02ac\u02cc\5*\26\2\u02ad\u02cc\5\66\34\2\u02ae\u02cc\5"+ 15934 "<\37\2\u02af\u02cc\5B\"\2\u02b0\u02cc\5H%\2\u02b1\u02cc\5N(\2\u02b2\u02cc"+ 15935 "\5T+\2\u02b3\u02cc\5Z.\2\u02b4\u02cc\5f\64\2\u02b5\u02cc\5`\61\2\u02b6"+ 15936 "\u02cc\5\16\b\2\u02b7\u02cc\5\24\13\2\u02b8\u02cc\5\32\16\2\u02b9\u02cc"+ 15937 "\5 \21\2\u02ba\u02cc\5&\24\2\u02bb\u02cc\5\62\32\2\u02bc\u02cc\58\35\2"+ 15938 "\u02bd\u02cc\5> \2\u02be\u02cc\5D#\2\u02bf\u02cc\5J&\2\u02c0\u02cc\5P"+ 15939 ")\2\u02c1\u02cc\5V,\2\u02c2\u02cc\5b\62\2\u02c3\u02cc\5\\/\2\u02c4\u02c5"+ 15940 "\6\31\n\2\u02c5\u02cc\7\3\2\2\u02c6\u02cc\5\u0094K\2\u02c7\u02cc\7\5\2"+ 15941 "\2\u02c8\u02cc\7\b\2\2\u02c9\u02cc\5\u0096L\2\u02ca\u02cc\5\u0092J\2\u02cb"+ 15942 "\u02a6\3\2\2\2\u02cb\u02a7\3\2\2\2\u02cb\u02a8\3\2\2\2\u02cb\u02a9\3\2"+ 15943 "\2\2\u02cb\u02aa\3\2\2\2\u02cb\u02ab\3\2\2\2\u02cb\u02ac\3\2\2\2\u02cb"+ 15944 "\u02ad\3\2\2\2\u02cb\u02ae\3\2\2\2\u02cb\u02af\3\2\2\2\u02cb\u02b0\3\2"+ 15945 "\2\2\u02cb\u02b1\3\2\2\2\u02cb\u02b2\3\2\2\2\u02cb\u02b3\3\2\2\2\u02cb"+ 15946 "\u02b4\3\2\2\2\u02cb\u02b5\3\2\2\2\u02cb\u02b6\3\2\2\2\u02cb\u02b7\3\2"+ 15947 "\2\2\u02cb\u02b8\3\2\2\2\u02cb\u02b9\3\2\2\2\u02cb\u02ba\3\2\2\2\u02cb"+ 15948 "\u02bb\3\2\2\2\u02cb\u02bc\3\2\2\2\u02cb\u02bd\3\2\2\2\u02cb\u02be\3\2"+ 15949 "\2\2\u02cb\u02bf\3\2\2\2\u02cb\u02c0\3\2\2\2\u02cb\u02c1\3\2\2\2\u02cb"+ 15950 "\u02c2\3\2\2\2\u02cb\u02c3\3\2\2\2\u02cb\u02c4\3\2\2\2\u02cb\u02c6\3\2"+ 15951 "\2\2\u02cb\u02c7\3\2\2\2\u02cb\u02c8\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cb"+ 15952 "\u02ca\3\2\2\2\u02cc\u02cf\3\2\2\2\u02cd\u02cb\3\2\2\2\u02cd\u02ce\3\2"+ 15953 "\2\2\u02ce\u02d0\3\2\2\2\u02cf\u02cd\3\2\2\2\u02d0\u02d1\5.\30\2\u02d1"+ 15954 "\61\3\2\2\2\u02d2\u02d3\7\7\2\2\u02d3\u02da\7C\2\2\u02d4\u02d9\5\n\6\2"+ 15955 "\u02d5\u02d9\7\b\2\2\u02d6\u02d9\7\3\2\2\u02d7\u02d9\7\6\2\2\u02d8\u02d4"+ 15956 "\3\2\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d8\u02d7\3\2\2\2\u02d9"+ 15957 "\u02dc\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2"+ 15958 "\2\2\u02dc\u02da\3\2\2\2\u02dd\u02de\79\2\2\u02de\63\3\2\2\2\u02df\u02e0"+ 15959 "\7\7\2\2\u02e0\u02e1\7;\2\2\u02e1\u02e5\7C\2\2\u02e2\u02e4\t\2\2\2\u02e3"+ 15960 "\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2"+ 15961 "\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\79\2\2\u02e9"+ 15962 "\65\3\2\2\2\u02ea\u0312\5\62\32\2\u02eb\u0311\5\f\7\2\u02ec\u0311\5j\66"+ 15963 "\2\u02ed\u0311\5\22\n\2\u02ee\u0311\5\30\r\2\u02ef\u0311\5\36\20\2\u02f0"+ 15964 "\u0311\5$\23\2\u02f1\u0311\5*\26\2\u02f2\u0311\5\60\31\2\u02f3\u0311\5"+ 15965 "<\37\2\u02f4\u0311\5B\"\2\u02f5\u0311\5H%\2\u02f6\u0311\5N(\2\u02f7\u0311"+ 15966 "\5T+\2\u02f8\u0311\5Z.\2\u02f9\u0311\5f\64\2\u02fa\u0311\5`\61\2\u02fb"+ 15967 "\u0311\5\16\b\2\u02fc\u0311\5\24\13\2\u02fd\u0311\5\32\16\2\u02fe\u0311"+ 15968 "\5 \21\2\u02ff\u0311\5&\24\2\u0300\u0311\5,\27\2\u0301\u0311\58\35\2\u0302"+ 15969 "\u0311\5> \2\u0303\u0311\5D#\2\u0304\u0311\5J&\2\u0305\u0311\5P)\2\u0306"+ 15970 "\u0311\5V,\2\u0307\u0311\5b\62\2\u0308\u0311\5\\/\2\u0309\u030a\6\34\13"+ 15971 "\2\u030a\u0311\7\3\2\2\u030b\u0311\5\u0094K\2\u030c\u0311\7\5\2\2\u030d"+ 15972 "\u0311\7\b\2\2\u030e\u0311\5\u0096L\2\u030f\u0311\5\u0092J\2\u0310\u02eb"+ 15973 "\3\2\2\2\u0310\u02ec\3\2\2\2\u0310\u02ed\3\2\2\2\u0310\u02ee\3\2\2\2\u0310"+ 15974 "\u02ef\3\2\2\2\u0310\u02f0\3\2\2\2\u0310\u02f1\3\2\2\2\u0310\u02f2\3\2"+ 15975 "\2\2\u0310\u02f3\3\2\2\2\u0310\u02f4\3\2\2\2\u0310\u02f5\3\2\2\2\u0310"+ 15976 "\u02f6\3\2\2\2\u0310\u02f7\3\2\2\2\u0310\u02f8\3\2\2\2\u0310\u02f9\3\2"+ 15977 "\2\2\u0310\u02fa\3\2\2\2\u0310\u02fb\3\2\2\2\u0310\u02fc\3\2\2\2\u0310"+ 15978 "\u02fd\3\2\2\2\u0310\u02fe\3\2\2\2\u0310\u02ff\3\2\2\2\u0310\u0300\3\2"+ 15979 "\2\2\u0310\u0301\3\2\2\2\u0310\u0302\3\2\2\2\u0310\u0303\3\2\2\2\u0310"+ 15980 "\u0304\3\2\2\2\u0310\u0305\3\2\2\2\u0310\u0306\3\2\2\2\u0310\u0307\3\2"+ 15981 "\2\2\u0310\u0308\3\2\2\2\u0310\u0309\3\2\2\2\u0310\u030b\3\2\2\2\u0310"+ 15982 "\u030c\3\2\2\2\u0310\u030d\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u030f\3\2"+ 15983 "\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+ 15984 "\u0315\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0316\5\64\33\2\u0316\67\3\2"+ 15985 "\2\2\u0317\u0318\7\7\2\2\u0318\u031f\7D\2\2\u0319\u031e\5\n\6\2\u031a"+ 15986 "\u031e\7\b\2\2\u031b\u031e\7\3\2\2\u031c\u031e\7\6\2\2\u031d\u0319\3\2"+ 15987 "\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031c\3\2\2\2\u031e"+ 15988 "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2"+ 15989 "\2\2\u0321\u031f\3\2\2\2\u0322\u0323\79\2\2\u03239\3\2\2\2\u0324\u0325"+ 15990 "\7\7\2\2\u0325\u0326\7;\2\2\u0326\u032a\7D\2\2\u0327\u0329\t\2\2\2\u0328"+ 15991 "\u0327\3\2\2\2\u0329\u032c\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u032b\3\2"+ 15992 "\2\2\u032b\u032d\3\2\2\2\u032c\u032a\3\2\2\2\u032d\u032e\79\2\2\u032e"+ 15993 ";\3\2\2\2\u032f\u0357\58\35\2\u0330\u0356\5\f\7\2\u0331\u0356\5j\66\2"+ 15994 "\u0332\u0356\5\22\n\2\u0333\u0356\5\30\r\2\u0334\u0356\5\36\20\2\u0335"+ 15995 "\u0356\5$\23\2\u0336\u0356\5*\26\2\u0337\u0356\5\60\31\2\u0338\u0356\5"+ 15996 "\66\34\2\u0339\u0356\5B\"\2\u033a\u0356\5H%\2\u033b\u0356\5N(\2\u033c"+ 15997 "\u0356\5T+\2\u033d\u0356\5Z.\2\u033e\u0356\5f\64\2\u033f\u0356\5`\61\2"+ 15998 "\u0340\u0356\5\16\b\2\u0341\u0356\5\24\13\2\u0342\u0356\5\32\16\2\u0343"+ 15999 "\u0356\5 \21\2\u0344\u0356\5&\24\2\u0345\u0356\5,\27\2\u0346\u0356\5\62"+ 16000 "\32\2\u0347\u0356\5> \2\u0348\u0356\5D#\2\u0349\u0356\5J&\2\u034a\u0356"+ 16001 "\5P)\2\u034b\u0356\5V,\2\u034c\u0356\5b\62\2\u034d\u0356\5\\/\2\u034e"+ 16002 "\u034f\6\37\f\2\u034f\u0356\7\3\2\2\u0350\u0356\5\u0094K\2\u0351\u0356"+ 16003 "\7\5\2\2\u0352\u0356\7\b\2\2\u0353\u0356\5\u0096L\2\u0354\u0356\5\u0092"+ 16004 "J\2\u0355\u0330\3\2\2\2\u0355\u0331\3\2\2\2\u0355\u0332\3\2\2\2\u0355"+ 16005 "\u0333\3\2\2\2\u0355\u0334\3\2\2\2\u0355\u0335\3\2\2\2\u0355\u0336\3\2"+ 16006 "\2\2\u0355\u0337\3\2\2\2\u0355\u0338\3\2\2\2\u0355\u0339\3\2\2\2\u0355"+ 16007 "\u033a\3\2\2\2\u0355\u033b\3\2\2\2\u0355\u033c\3\2\2\2\u0355\u033d\3\2"+ 16008 "\2\2\u0355\u033e\3\2\2\2\u0355\u033f\3\2\2\2\u0355\u0340\3\2\2\2\u0355"+ 16009 "\u0341\3\2\2\2\u0355\u0342\3\2\2\2\u0355\u0343\3\2\2\2\u0355\u0344\3\2"+ 16010 "\2\2\u0355\u0345\3\2\2\2\u0355\u0346\3\2\2\2\u0355\u0347\3\2\2\2\u0355"+ 16011 "\u0348\3\2\2\2\u0355\u0349\3\2\2\2\u0355\u034a\3\2\2\2\u0355\u034b\3\2"+ 16012 "\2\2\u0355\u034c\3\2\2\2\u0355\u034d\3\2\2\2\u0355\u034e\3\2\2\2\u0355"+ 16013 "\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0355\u0352\3\2\2\2\u0355\u0353\3\2"+ 16014 "\2\2\u0355\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357"+ 16015 "\u0358\3\2\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\5:"+ 16016 "\36\2\u035b=\3\2\2\2\u035c\u035d\7\7\2\2\u035d\u0364\7E\2\2\u035e\u0363"+ 16017 "\5\n\6\2\u035f\u0363\7\b\2\2\u0360\u0363\7\3\2\2\u0361\u0363\7\6\2\2\u0362"+ 16018 "\u035e\3\2\2\2\u0362\u035f\3\2\2\2\u0362\u0360\3\2\2\2\u0362\u0361\3\2"+ 16019 "\2\2\u0363\u0366\3\2\2\2\u0364\u0362\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+ 16020 "\u0367\3\2\2\2\u0366\u0364\3\2\2\2\u0367\u0368\79\2\2\u0368?\3\2\2\2\u0369"+ 16021 "\u036a\7\7\2\2\u036a\u036b\7;\2\2\u036b\u036f\7E\2\2\u036c\u036e\t\2\2"+ 16022 "\2\u036d\u036c\3\2\2\2\u036e\u0371\3\2\2\2\u036f\u036d\3\2\2\2\u036f\u0370"+ 16023 "\3\2\2\2\u0370\u0372\3\2\2\2\u0371\u036f\3\2\2\2\u0372\u0373\79\2\2\u0373"+ 16024 "A\3\2\2\2\u0374\u039c\5> \2\u0375\u039b\5\f\7\2\u0376\u039b\5j\66\2\u0377"+ 16025 "\u039b\5\22\n\2\u0378\u039b\5\30\r\2\u0379\u039b\5\36\20\2\u037a\u039b"+ 16026 "\5$\23\2\u037b\u039b\5*\26\2\u037c\u039b\5\60\31\2\u037d\u039b\5\66\34"+ 16027 "\2\u037e\u039b\5<\37\2\u037f\u039b\5H%\2\u0380\u039b\5N(\2\u0381\u039b"+ 16028 "\5T+\2\u0382\u039b\5Z.\2\u0383\u039b\5f\64\2\u0384\u039b\5`\61\2\u0385"+ 16029 "\u039b\5\16\b\2\u0386\u039b\5\24\13\2\u0387\u039b\5\32\16\2\u0388\u039b"+ 16030 "\5 \21\2\u0389\u039b\5&\24\2\u038a\u039b\5,\27\2\u038b\u039b\5\62\32\2"+ 16031 "\u038c\u039b\58\35\2\u038d\u039b\5D#\2\u038e\u039b\5J&\2\u038f\u039b\5"+ 16032 "P)\2\u0390\u039b\5V,\2\u0391\u039b\5b\62\2\u0392\u039b\5\\/\2\u0393\u0394"+ 16033 "\6\"\r\2\u0394\u039b\7\3\2\2\u0395\u039b\5\u0094K\2\u0396\u039b\7\5\2"+ 16034 "\2\u0397\u039b\7\b\2\2\u0398\u039b\5\u0096L\2\u0399\u039b\5\u0092J\2\u039a"+ 16035 "\u0375\3\2\2\2\u039a\u0376\3\2\2\2\u039a\u0377\3\2\2\2\u039a\u0378\3\2"+ 16036 "\2\2\u039a\u0379\3\2\2\2\u039a\u037a\3\2\2\2\u039a\u037b\3\2\2\2\u039a"+ 16037 "\u037c\3\2\2\2\u039a\u037d\3\2\2\2\u039a\u037e\3\2\2\2\u039a\u037f\3\2"+ 16038 "\2\2\u039a\u0380\3\2\2\2\u039a\u0381\3\2\2\2\u039a\u0382\3\2\2\2\u039a"+ 16039 "\u0383\3\2\2\2\u039a\u0384\3\2\2\2\u039a\u0385\3\2\2\2\u039a\u0386\3\2"+ 16040 "\2\2\u039a\u0387\3\2\2\2\u039a\u0388\3\2\2\2\u039a\u0389\3\2\2\2\u039a"+ 16041 "\u038a\3\2\2\2\u039a\u038b\3\2\2\2\u039a\u038c\3\2\2\2\u039a\u038d\3\2"+ 16042 "\2\2\u039a\u038e\3\2\2\2\u039a\u038f\3\2\2\2\u039a\u0390\3\2\2\2\u039a"+ 16043 "\u0391\3\2\2\2\u039a\u0392\3\2\2\2\u039a\u0393\3\2\2\2\u039a\u0395\3\2"+ 16044 "\2\2\u039a\u0396\3\2\2\2\u039a\u0397\3\2\2\2\u039a\u0398\3\2\2\2\u039a"+ 16045 "\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2"+ 16046 "\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a0\5@!\2\u03a0C"+ 16047 "\3\2\2\2\u03a1\u03a2\7\7\2\2\u03a2\u03a9\7F\2\2\u03a3\u03a8\5\n\6\2\u03a4"+ 16048 "\u03a8\7\b\2\2\u03a5\u03a8\7\3\2\2\u03a6\u03a8\7\6\2\2\u03a7\u03a3\3\2"+ 16049 "\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6\3\2\2\2\u03a8"+ 16050 "\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ac\3\2"+ 16051 "\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ad\79\2\2\u03adE\3\2\2\2\u03ae\u03af"+ 16052 "\7\7\2\2\u03af\u03b0\7;\2\2\u03b0\u03b4\7F\2\2\u03b1\u03b3\t\2\2\2\u03b2"+ 16053 "\u03b1\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2"+ 16054 "\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b8\79\2\2\u03b8"+ 16055 "G\3\2\2\2\u03b9\u03e1\5D#\2\u03ba\u03e0\5\f\7\2\u03bb\u03e0\5j\66\2\u03bc"+ 16056 "\u03e0\5\22\n\2\u03bd\u03e0\5\30\r\2\u03be\u03e0\5\36\20\2\u03bf\u03e0"+ 16057 "\5$\23\2\u03c0\u03e0\5*\26\2\u03c1\u03e0\5\60\31\2\u03c2\u03e0\5\66\34"+ 16058 "\2\u03c3\u03e0\5<\37\2\u03c4\u03e0\5B\"\2\u03c5\u03e0\5N(\2\u03c6\u03e0"+ 16059 "\5T+\2\u03c7\u03e0\5Z.\2\u03c8\u03e0\5f\64\2\u03c9\u03e0\5`\61\2\u03ca"+ 16060 "\u03e0\5\16\b\2\u03cb\u03e0\5\24\13\2\u03cc\u03e0\5\32\16\2\u03cd\u03e0"+ 16061 "\5 \21\2\u03ce\u03e0\5&\24\2\u03cf\u03e0\5,\27\2\u03d0\u03e0\5\62\32\2"+ 16062 "\u03d1\u03e0\58\35\2\u03d2\u03e0\5> \2\u03d3\u03e0\5J&\2\u03d4\u03e0\5"+ 16063 "P)\2\u03d5\u03e0\5V,\2\u03d6\u03e0\5b\62\2\u03d7\u03e0\5\\/\2\u03d8\u03d9"+ 16064 "\6%\16\2\u03d9\u03e0\7\3\2\2\u03da\u03e0\5\u0094K\2\u03db\u03e0\7\5\2"+ 16065 "\2\u03dc\u03e0\7\b\2\2\u03dd\u03e0\5\u0096L\2\u03de\u03e0\5\u0092J\2\u03df"+ 16066 "\u03ba\3\2\2\2\u03df\u03bb\3\2\2\2\u03df\u03bc\3\2\2\2\u03df\u03bd\3\2"+ 16067 "\2\2\u03df\u03be\3\2\2\2\u03df\u03bf\3\2\2\2\u03df\u03c0\3\2\2\2\u03df"+ 16068 "\u03c1\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03c3\3\2\2\2\u03df\u03c4\3\2"+ 16069 "\2\2\u03df\u03c5\3\2\2\2\u03df\u03c6\3\2\2\2\u03df\u03c7\3\2\2\2\u03df"+ 16070 "\u03c8\3\2\2\2\u03df\u03c9\3\2\2\2\u03df\u03ca\3\2\2\2\u03df\u03cb\3\2"+ 16071 "\2\2\u03df\u03cc\3\2\2\2\u03df\u03cd\3\2\2\2\u03df\u03ce\3\2\2\2\u03df"+ 16072 "\u03cf\3\2\2\2\u03df\u03d0\3\2\2\2\u03df\u03d1\3\2\2\2\u03df\u03d2\3\2"+ 16073 "\2\2\u03df\u03d3\3\2\2\2\u03df\u03d4\3\2\2\2\u03df\u03d5\3\2\2\2\u03df"+ 16074 "\u03d6\3\2\2\2\u03df\u03d7\3\2\2\2\u03df\u03d8\3\2\2\2\u03df\u03da\3\2"+ 16075 "\2\2\u03df\u03db\3\2\2\2\u03df\u03dc\3\2\2\2\u03df\u03dd\3\2\2\2\u03df"+ 16076 "\u03de\3\2\2\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2"+ 16077 "\2\2\u03e2\u03e4\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5F$\2\u03e5I"+ 16078 "\3\2\2\2\u03e6\u03e7\7\7\2\2\u03e7\u03ee\7G\2\2\u03e8\u03ed\5\n\6\2\u03e9"+ 16079 "\u03ed\7\b\2\2\u03ea\u03ed\7\3\2\2\u03eb\u03ed\7\6\2\2\u03ec\u03e8\3\2"+ 16080 "\2\2\u03ec\u03e9\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed"+ 16081 "\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f1\3\2"+ 16082 "\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03f2\79\2\2\u03f2K\3\2\2\2\u03f3\u03f4"+ 16083 "\7\7\2\2\u03f4\u03f5\7;\2\2\u03f5\u03f9\7G\2\2\u03f6\u03f8\t\2\2\2\u03f7"+ 16084 "\u03f6\3\2\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2"+ 16085 "\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03fd\79\2\2\u03fd"+ 16086 "M\3\2\2\2\u03fe\u0426\5J&\2\u03ff\u0425\5\f\7\2\u0400\u0425\5j\66\2\u0401"+ 16087 "\u0425\5\22\n\2\u0402\u0425\5\30\r\2\u0403\u0425\5\36\20\2\u0404\u0425"+ 16088 "\5$\23\2\u0405\u0425\5*\26\2\u0406\u0425\5\60\31\2\u0407\u0425\5\66\34"+ 16089 "\2\u0408\u0425\5<\37\2\u0409\u0425\5B\"\2\u040a\u0425\5H%\2\u040b\u0425"+ 16090 "\5T+\2\u040c\u0425\5Z.\2\u040d\u0425\5f\64\2\u040e\u0425\5`\61\2\u040f"+ 16091 "\u0425\5\16\b\2\u0410\u0425\5\24\13\2\u0411\u0425\5\32\16\2\u0412\u0425"+ 16092 "\5 \21\2\u0413\u0425\5&\24\2\u0414\u0425\5,\27\2\u0415\u0425\5\62\32\2"+ 16093 "\u0416\u0425\58\35\2\u0417\u0425\5> \2\u0418\u0425\5D#\2\u0419\u0425\5"+ 16094 "P)\2\u041a\u0425\5V,\2\u041b\u0425\5b\62\2\u041c\u0425\5\\/\2\u041d\u041e"+ 16095 "\6(\17\2\u041e\u0425\7\3\2\2\u041f\u0425\5\u0094K\2\u0420\u0425\7\5\2"+ 16096 "\2\u0421\u0425\7\b\2\2\u0422\u0425\5\u0096L\2\u0423\u0425\5\u0092J\2\u0424"+ 16097 "\u03ff\3\2\2\2\u0424\u0400\3\2\2\2\u0424\u0401\3\2\2\2\u0424\u0402\3\2"+ 16098 "\2\2\u0424\u0403\3\2\2\2\u0424\u0404\3\2\2\2\u0424\u0405\3\2\2\2\u0424"+ 16099 "\u0406\3\2\2\2\u0424\u0407\3\2\2\2\u0424\u0408\3\2\2\2\u0424\u0409\3\2"+ 16100 "\2\2\u0424\u040a\3\2\2\2\u0424\u040b\3\2\2\2\u0424\u040c\3\2\2\2\u0424"+ 16101 "\u040d\3\2\2\2\u0424\u040e\3\2\2\2\u0424\u040f\3\2\2\2\u0424\u0410\3\2"+ 16102 "\2\2\u0424\u0411\3\2\2\2\u0424\u0412\3\2\2\2\u0424\u0413\3\2\2\2\u0424"+ 16103 "\u0414\3\2\2\2\u0424\u0415\3\2\2\2\u0424\u0416\3\2\2\2\u0424\u0417\3\2"+ 16104 "\2\2\u0424\u0418\3\2\2\2\u0424\u0419\3\2\2\2\u0424\u041a\3\2\2\2\u0424"+ 16105 "\u041b\3\2\2\2\u0424\u041c\3\2\2\2\u0424\u041d\3\2\2\2\u0424\u041f\3\2"+ 16106 "\2\2\u0424\u0420\3\2\2\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424"+ 16107 "\u0423\3\2\2\2\u0425\u0428\3\2\2\2\u0426\u0424\3\2\2\2\u0426\u0427\3\2"+ 16108 "\2\2\u0427\u0429\3\2\2\2\u0428\u0426\3\2\2\2\u0429\u042a\5L\'\2\u042a"+ 16109 "O\3\2\2\2\u042b\u042c\7\7\2\2\u042c\u0433\7H\2\2\u042d\u0432\5\n\6\2\u042e"+ 16110 "\u0432\7\b\2\2\u042f\u0432\7\3\2\2\u0430\u0432\7\6\2\2\u0431\u042d\3\2"+ 16111 "\2\2\u0431\u042e\3\2\2\2\u0431\u042f\3\2\2\2\u0431\u0430\3\2\2\2\u0432"+ 16112 "\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0436\3\2"+ 16113 "\2\2\u0435\u0433\3\2\2\2\u0436\u0437\79\2\2\u0437Q\3\2\2\2\u0438\u0439"+ 16114 "\7\7\2\2\u0439\u043a\7;\2\2\u043a\u043e\7H\2\2\u043b\u043d\t\2\2\2\u043c"+ 16115 "\u043b\3\2\2\2\u043d\u0440\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2"+ 16116 "\2\2\u043f\u0441\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0442\79\2\2\u0442"+ 16117 "S\3\2\2\2\u0443\u046b\5P)\2\u0444\u046a\5\f\7\2\u0445\u046a\5j\66\2\u0446"+ 16118 "\u046a\5\22\n\2\u0447\u046a\5\30\r\2\u0448\u046a\5\36\20\2\u0449\u046a"+ 16119 "\5$\23\2\u044a\u046a\5*\26\2\u044b\u046a\5\60\31\2\u044c\u046a\5\66\34"+ 16120 "\2\u044d\u046a\5<\37\2\u044e\u046a\5B\"\2\u044f\u046a\5H%\2\u0450\u046a"+ 16121 "\5N(\2\u0451\u046a\5Z.\2\u0452\u046a\5f\64\2\u0453\u046a\5`\61\2\u0454"+ 16122 "\u046a\5\16\b\2\u0455\u046a\5\24\13\2\u0456\u046a\5\32\16\2\u0457\u046a"+ 16123 "\5 \21\2\u0458\u046a\5&\24\2\u0459\u046a\5,\27\2\u045a\u046a\5\62\32\2"+ 16124 "\u045b\u046a\58\35\2\u045c\u046a\5> \2\u045d\u046a\5D#\2\u045e\u046a\5"+ 16125 "J&\2\u045f\u046a\5V,\2\u0460\u046a\5b\62\2\u0461\u046a\5\\/\2\u0462\u0463"+ 16126 "\6+\20\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094K\2\u0465\u046a\7\5\2"+ 16127 "\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468\u046a\5\u0092J\2\u0469"+ 16128 "\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469\u0447\3\2"+ 16129 "\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2\2\2\u0469"+ 16130 "\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469\u044e\3\2"+ 16131 "\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2\2\2\u0469"+ 16132 "\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469\u0455\3\2"+ 16133 "\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2\2\2\u0469"+ 16134 "\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469\u045c\3\2"+ 16135 "\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2\2\2\u0469"+ 16136 "\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469\u0464\3\2"+ 16137 "\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2\2\2\u0469"+ 16138 "\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2"+ 16139 "\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5R*\2\u046fU"+ 16140 "\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7I\2\2\u0472\u0477\5\n\6\2\u0473"+ 16141 "\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476\u0472\3\2"+ 16142 "\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477"+ 16143 "\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u047b\3\2"+ 16144 "\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cW\3\2\2\2\u047d\u047e"+ 16145 "\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7I\2\2\u0480\u0482\t\2\2\2\u0481"+ 16146 "\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484\3\2"+ 16147 "\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+ 16148 "Y\3\2\2\2\u0488\u04b0\5V,\2\u0489\u04af\5\f\7\2\u048a\u04af\5j\66\2\u048b"+ 16149 "\u04af\5\22\n\2\u048c\u04af\5\30\r\2\u048d\u04af\5\36\20\2\u048e\u04af"+ 16150 "\5$\23\2\u048f\u04af\5*\26\2\u0490\u04af\5\60\31\2\u0491\u04af\5\66\34"+ 16151 "\2\u0492\u04af\5<\37\2\u0493\u04af\5B\"\2\u0494\u04af\5H%\2\u0495\u04af"+ 16152 "\5N(\2\u0496\u04af\5T+\2\u0497\u04af\5f\64\2\u0498\u04af\5`\61\2\u0499"+ 16153 "\u04af\5\16\b\2\u049a\u04af\5\24\13\2\u049b\u04af\5\32\16\2\u049c\u04af"+ 16154 "\5 \21\2\u049d\u04af\5&\24\2\u049e\u04af\5,\27\2\u049f\u04af\5\62\32\2"+ 16155 "\u04a0\u04af\58\35\2\u04a1\u04af\5> \2\u04a2\u04af\5D#\2\u04a3\u04af\5"+ 16156 "J&\2\u04a4\u04af\5P)\2\u04a5\u04af\5b\62\2\u04a6\u04af\5\\/\2\u04a7\u04a8"+ 16157 "\6.\21\2\u04a8\u04af\7\3\2\2\u04a9\u04af\5\u0094K\2\u04aa\u04af\7\5\2"+ 16158 "\2\u04ab\u04af\7\b\2\2\u04ac\u04af\5\u0096L\2\u04ad\u04af\5\u0092J\2\u04ae"+ 16159 "\u0489\3\2\2\2\u04ae\u048a\3\2\2\2\u04ae\u048b\3\2\2\2\u04ae\u048c\3\2"+ 16160 "\2\2\u04ae\u048d\3\2\2\2\u04ae\u048e\3\2\2\2\u04ae\u048f\3\2\2\2\u04ae"+ 16161 "\u0490\3\2\2\2\u04ae\u0491\3\2\2\2\u04ae\u0492\3\2\2\2\u04ae\u0493\3\2"+ 16162 "\2\2\u04ae\u0494\3\2\2\2\u04ae\u0495\3\2\2\2\u04ae\u0496\3\2\2\2\u04ae"+ 16163 "\u0497\3\2\2\2\u04ae\u0498\3\2\2\2\u04ae\u0499\3\2\2\2\u04ae\u049a\3\2"+ 16164 "\2\2\u04ae\u049b\3\2\2\2\u04ae\u049c\3\2\2\2\u04ae\u049d\3\2\2\2\u04ae"+ 16165 "\u049e\3\2\2\2\u04ae\u049f\3\2\2\2\u04ae\u04a0\3\2\2\2\u04ae\u04a1\3\2"+ 16166 "\2\2\u04ae\u04a2\3\2\2\2\u04ae\u04a3\3\2\2\2\u04ae\u04a4\3\2\2\2\u04ae"+ 16167 "\u04a5\3\2\2\2\u04ae\u04a6\3\2\2\2\u04ae\u04a7\3\2\2\2\u04ae\u04a9\3\2"+ 16168 "\2\2\u04ae\u04aa\3\2\2\2\u04ae\u04ab\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae"+ 16169 "\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b0\u04b1\3\2"+ 16170 "\2\2\u04b1\u04b3\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04b4\5X-\2\u04b4["+ 16171 "\3\2\2\2\u04b5\u04b6\7\7\2\2\u04b6\u04bd\7J\2\2\u04b7\u04bc\5\n\6\2\u04b8"+ 16172 "\u04bc\7\b\2\2\u04b9\u04bc\7\3\2\2\u04ba\u04bc\7\6\2\2\u04bb\u04b7\3\2"+ 16173 "\2\2\u04bb\u04b8\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bb\u04ba\3\2\2\2\u04bc"+ 16174 "\u04bf\3\2\2\2\u04bd\u04bb\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04c0\3\2"+ 16175 "\2\2\u04bf\u04bd\3\2\2\2\u04c0\u04c1\79\2\2\u04c1]\3\2\2\2\u04c2\u04c3"+ 16176 "\7\7\2\2\u04c3\u04c4\7;\2\2\u04c4\u04c8\7J\2\2\u04c5\u04c7\t\2\2\2\u04c6"+ 16177 "\u04c5\3\2\2\2\u04c7\u04ca\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c8\u04c9\3\2"+ 16178 "\2\2\u04c9\u04cb\3\2\2\2\u04ca\u04c8\3\2\2\2\u04cb\u04cc\79\2\2\u04cc"+ 16179 "_\3\2\2\2\u04cd\u04f5\5\\/\2\u04ce\u04f4\5\f\7\2\u04cf\u04f4\5j\66\2\u04d0"+ 16180 "\u04f4\5\22\n\2\u04d1\u04f4\5\30\r\2\u04d2\u04f4\5\36\20\2\u04d3\u04f4"+ 16181 "\5$\23\2\u04d4\u04f4\5*\26\2\u04d5\u04f4\5\60\31\2\u04d6\u04f4\5\66\34"+ 16182 "\2\u04d7\u04f4\5<\37\2\u04d8\u04f4\5B\"\2\u04d9\u04f4\5H%\2\u04da\u04f4"+ 16183 "\5N(\2\u04db\u04f4\5T+\2\u04dc\u04f4\5Z.\2\u04dd\u04f4\5f\64\2\u04de\u04f4"+ 16184 "\5\16\b\2\u04df\u04f4\5\24\13\2\u04e0\u04f4\5\32\16\2\u04e1\u04f4\5 \21"+ 16185 "\2\u04e2\u04f4\5&\24\2\u04e3\u04f4\5,\27\2\u04e4\u04f4\5\62\32\2\u04e5"+ 16186 "\u04f4\58\35\2\u04e6\u04f4\5> \2\u04e7\u04f4\5D#\2\u04e8\u04f4\5J&\2\u04e9"+ 16187 "\u04f4\5P)\2\u04ea\u04f4\5V,\2\u04eb\u04f4\5b\62\2\u04ec\u04ed\6\61\22"+ 16188 "\2\u04ed\u04f4\7\3\2\2\u04ee\u04f4\5\u0094K\2\u04ef\u04f4\7\5\2\2\u04f0"+ 16189 "\u04f4\7\b\2\2\u04f1\u04f4\5\u0096L\2\u04f2\u04f4\5\u0092J\2\u04f3\u04ce"+ 16190 "\3\2\2\2\u04f3\u04cf\3\2\2\2\u04f3\u04d0\3\2\2\2\u04f3\u04d1\3\2\2\2\u04f3"+ 16191 "\u04d2\3\2\2\2\u04f3\u04d3\3\2\2\2\u04f3\u04d4\3\2\2\2\u04f3\u04d5\3\2"+ 16192 "\2\2\u04f3\u04d6\3\2\2\2\u04f3\u04d7\3\2\2\2\u04f3\u04d8\3\2\2\2\u04f3"+ 16193 "\u04d9\3\2\2\2\u04f3\u04da\3\2\2\2\u04f3\u04db\3\2\2\2\u04f3\u04dc\3\2"+ 16194 "\2\2\u04f3\u04dd\3\2\2\2\u04f3\u04de\3\2\2\2\u04f3\u04df\3\2\2\2\u04f3"+ 16195 "\u04e0\3\2\2\2\u04f3\u04e1\3\2\2\2\u04f3\u04e2\3\2\2\2\u04f3\u04e3\3\2"+ 16196 "\2\2\u04f3\u04e4\3\2\2\2\u04f3\u04e5\3\2\2\2\u04f3\u04e6\3\2\2\2\u04f3"+ 16197 "\u04e7\3\2\2\2\u04f3\u04e8\3\2\2\2\u04f3\u04e9\3\2\2\2\u04f3\u04ea\3\2"+ 16198 "\2\2\u04f3\u04eb\3\2\2\2\u04f3\u04ec\3\2\2\2\u04f3\u04ee\3\2\2\2\u04f3"+ 16199 "\u04ef\3\2\2\2\u04f3\u04f0\3\2\2\2\u04f3\u04f1\3\2\2\2\u04f3\u04f2\3\2"+ 16200 "\2\2\u04f4\u04f7\3\2\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6"+ 16201 "\u04f8\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f8\u04f9\5^\60\2\u04f9a\3\2\2\2"+ 16202 "\u04fa\u04fb\7\7\2\2\u04fb\u0502\7K\2\2\u04fc\u0501\5\n\6\2\u04fd\u0501"+ 16203 "\7\b\2\2\u04fe\u0501\7\3\2\2\u04ff\u0501\7\6\2\2\u0500\u04fc\3\2\2\2\u0500"+ 16204 "\u04fd\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u04ff\3\2\2\2\u0501\u0504\3\2"+ 16205 "\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0505\3\2\2\2\u0504"+ 16206 "\u0502\3\2\2\2\u0505\u0506\79\2\2\u0506c\3\2\2\2\u0507\u0508\7\7\2\2\u0508"+ 16207 "\u0509\7;\2\2\u0509\u050d\7K\2\2\u050a\u050c\t\2\2\2\u050b\u050a\3\2\2"+ 16208 "\2\u050c\u050f\3\2\2\2\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u0510"+ 16209 "\3\2\2\2\u050f\u050d\3\2\2\2\u0510\u0511\79\2\2\u0511e\3\2\2\2\u0512\u053a"+ 16210 "\5b\62\2\u0513\u0539\5\f\7\2\u0514\u0539\5j\66\2\u0515\u0539\5\22\n\2"+ 16211 "\u0516\u0539\5\30\r\2\u0517\u0539\5\36\20\2\u0518\u0539\5$\23\2\u0519"+ 16212 "\u0539\5*\26\2\u051a\u0539\5\60\31\2\u051b\u0539\5\66\34\2\u051c\u0539"+ 16213 "\5<\37\2\u051d\u0539\5B\"\2\u051e\u0539\5H%\2\u051f\u0539\5N(\2\u0520"+ 16214 "\u0539\5T+\2\u0521\u0539\5Z.\2\u0522\u0539\5`\61\2\u0523\u0539\5\16\b"+ 16215 "\2\u0524\u0539\5\24\13\2\u0525\u0539\5\32\16\2\u0526\u0539\5 \21\2\u0527"+ 16216 "\u0539\5&\24\2\u0528\u0539\5,\27\2\u0529\u0539\5\62\32\2\u052a\u0539\5"+ 16217 "8\35\2\u052b\u0539\5> \2\u052c\u0539\5D#\2\u052d\u0539\5J&\2\u052e\u0539"+ 16218 "\5P)\2\u052f\u0539\5V,\2\u0530\u0539\5\\/\2\u0531\u0532\6\64\23\2\u0532"+ 16219 "\u0539\7\3\2\2\u0533\u0539\5\u0094K\2\u0534\u0539\7\5\2\2\u0535\u0539"+ 16220 "\7\b\2\2\u0536\u0539\5\u0096L\2\u0537\u0539\5\u0092J\2\u0538\u0513\3\2"+ 16221 "\2\2\u0538\u0514\3\2\2\2\u0538\u0515\3\2\2\2\u0538\u0516\3\2\2\2\u0538"+ 16222 "\u0517\3\2\2\2\u0538\u0518\3\2\2\2\u0538\u0519\3\2\2\2\u0538\u051a\3\2"+ 16223 "\2\2\u0538\u051b\3\2\2\2\u0538\u051c\3\2\2\2\u0538\u051d\3\2\2\2\u0538"+ 16224 "\u051e\3\2\2\2\u0538\u051f\3\2\2\2\u0538\u0520\3\2\2\2\u0538\u0521\3\2"+ 16225 "\2\2\u0538\u0522\3\2\2\2\u0538\u0523\3\2\2\2\u0538\u0524\3\2\2\2\u0538"+ 16226 "\u0525\3\2\2\2\u0538\u0526\3\2\2\2\u0538\u0527\3\2\2\2\u0538\u0528\3\2"+ 16227 "\2\2\u0538\u0529\3\2\2\2\u0538\u052a\3\2\2\2\u0538\u052b\3\2\2\2\u0538"+ 16228 "\u052c\3\2\2\2\u0538\u052d\3\2\2\2\u0538\u052e\3\2\2\2\u0538\u052f\3\2"+ 16229 "\2\2\u0538\u0530\3\2\2\2\u0538\u0531\3\2\2\2\u0538\u0533\3\2\2\2\u0538"+ 16230 "\u0534\3\2\2\2\u0538\u0535\3\2\2\2\u0538\u0536\3\2\2\2\u0538\u0537\3\2"+ 16231 "\2\2\u0539\u053c\3\2\2\2\u053a\u0538\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+ 16232 "\u053d\3\2\2\2\u053c\u053a\3\2\2\2\u053d\u053e\5d\63\2\u053eg\3\2\2\2"+ 16233 "\u053f\u054f\5j\66\2\u0540\u054f\5l\67\2\u0541\u054f\5n8\2\u0542\u054f"+ 16234 "\5p9\2\u0543\u054f\5r:\2\u0544\u054f\5t;\2\u0545\u054f\5v<\2\u0546\u054f"+ 16235 "\5x=\2\u0547\u054f\5z>\2\u0548\u054f\5|?\2\u0549\u054f\5~@\2\u054a\u054f"+ 16236 "\5\u0080A\2\u054b\u054f\5\u0082B\2\u054c\u054f\5\u0084C\2\u054d\u054f"+ 16237 "\5\u0086D\2\u054e\u053f\3\2\2\2\u054e\u0540\3\2\2\2\u054e\u0541\3\2\2"+ 16238 "\2\u054e\u0542\3\2\2\2\u054e\u0543\3\2\2\2\u054e\u0544\3\2\2\2\u054e\u0545"+ 16239 "\3\2\2\2\u054e\u0546\3\2\2\2\u054e\u0547\3\2\2\2\u054e\u0548\3\2\2\2\u054e"+ 16240 "\u0549\3\2\2\2\u054e\u054a\3\2\2\2\u054e\u054b\3\2\2\2\u054e\u054c\3\2"+ 16241 "\2\2\u054e\u054d\3\2\2\2\u054fi\3\2\2\2\u0550\u0551\7\7\2\2\u0551\u0558"+ 16242 "\t\3\2\2\u0552\u0557\5\n\6\2\u0553\u0557\7\b\2\2\u0554\u0557\7\3\2\2\u0555"+ 16243 "\u0557\7\6\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+ 16244 "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+ 16245 "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7:"+ 16246 "\2\2\u055ck\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7L\2\2\u055f\u0564"+ 16247 "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+ 16248 "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+ 16249 "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+ 16250 "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\t\4\2\2\u0569m\3\2\2\2"+ 16251 "\u056a\u056b\7\7\2\2\u056b\u0572\7M\2\2\u056c\u0571\5\n\6\2\u056d\u0571"+ 16252 "\7\b\2\2\u056e\u0571\7\3\2\2\u056f\u0571\7\6\2\2\u0570\u056c\3\2\2\2\u0570"+ 16253 "\u056d\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2"+ 16254 "\2\2\u0572\u0570\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574"+ 16255 "\u0572\3\2\2\2\u0575\u0576\t\4\2\2\u0576o\3\2\2\2\u0577\u0578\7\7\2\2"+ 16256 "\u0578\u057f\7N\2\2\u0579\u057e\5\n\6\2\u057a\u057e\7\b\2\2\u057b\u057e"+ 16257 "\7\3\2\2\u057c\u057e\7\6\2\2\u057d\u0579\3\2\2\2\u057d\u057a\3\2\2\2\u057d"+ 16258 "\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e\u0581\3\2\2\2\u057f\u057d\3\2"+ 16259 "\2\2\u057f\u0580\3\2\2\2\u0580\u0582\3\2\2\2\u0581\u057f\3\2\2\2\u0582"+ 16260 "\u0583\t\4\2\2\u0583q\3\2\2\2\u0584\u0585\7\7\2\2\u0585\u058c\7O\2\2\u0586"+ 16261 "\u058b\5\n\6\2\u0587\u058b\7\b\2\2\u0588\u058b\7\3\2\2\u0589\u058b\7\6"+ 16262 "\2\2\u058a\u0586\3\2\2\2\u058a\u0587\3\2\2\2\u058a\u0588\3\2\2\2\u058a"+ 16263 "\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2\2\2\u058c\u058d\3\2"+ 16264 "\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f\u0590\t\4\2\2\u0590"+ 16265 "s\3\2\2\2\u0591\u0592\7\7\2\2\u0592\u0599\7P\2\2\u0593\u0598\5\n\6\2\u0594"+ 16266 "\u0598\7\b\2\2\u0595\u0598\7\3\2\2\u0596\u0598\7\6\2\2\u0597\u0593\3\2"+ 16267 "\2\2\u0597\u0594\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0596\3\2\2\2\u0598"+ 16268 "\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c\3\2"+ 16269 "\2\2\u059b\u0599\3\2\2\2\u059c\u059d\t\4\2\2\u059du\3\2\2\2\u059e\u059f"+ 16270 "\7\7\2\2\u059f\u05a6\7Q\2\2\u05a0\u05a5\5\n\6\2\u05a1\u05a5\7\b\2\2\u05a2"+ 16271 "\u05a5\7\3\2\2\u05a3\u05a5\7\6\2\2\u05a4\u05a0\3\2\2\2\u05a4\u05a1\3\2"+ 16272 "\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3\3\2\2\2\u05a5\u05a8\3\2\2\2\u05a6"+ 16273 "\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a9\3\2\2\2\u05a8\u05a6\3\2"+ 16274 "\2\2\u05a9\u05aa\t\4\2\2\u05aaw\3\2\2\2\u05ab\u05ac\7\7\2\2\u05ac\u05b3"+ 16275 "\7R\2\2\u05ad\u05b2\5\n\6\2\u05ae\u05b2\7\b\2\2\u05af\u05b2\7\3\2\2\u05b0"+ 16276 "\u05b2\7\6\2\2\u05b1\u05ad\3\2\2\2\u05b1\u05ae\3\2\2\2\u05b1\u05af\3\2"+ 16277 "\2\2\u05b1\u05b0\3\2\2\2\u05b2\u05b5\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b3"+ 16278 "\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b3\3\2\2\2\u05b6\u05b7\t\4"+ 16279 "\2\2\u05b7y\3\2\2\2\u05b8\u05b9\7\7\2\2\u05b9\u05c0\7S\2\2\u05ba\u05bf"+ 16280 "\5\n\6\2\u05bb\u05bf\7\b\2\2\u05bc\u05bf\7\3\2\2\u05bd\u05bf\7\6\2\2\u05be"+ 16281 "\u05ba\3\2\2\2\u05be\u05bb\3\2\2\2\u05be\u05bc\3\2\2\2\u05be\u05bd\3\2"+ 16282 "\2\2\u05bf\u05c2\3\2\2\2\u05c0\u05be\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1"+ 16283 "\u05c3\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c3\u05c4\t\4\2\2\u05c4{\3\2\2\2"+ 16284 "\u05c5\u05c6\7\7\2\2\u05c6\u05cd\7T\2\2\u05c7\u05cc\5\n\6\2\u05c8\u05cc"+ 16285 "\7\b\2\2\u05c9\u05cc\7\3\2\2\u05ca\u05cc\7\6\2\2\u05cb\u05c7\3\2\2\2\u05cb"+ 16286 "\u05c8\3\2\2\2\u05cb\u05c9\3\2\2\2\u05cb\u05ca\3\2\2\2\u05cc\u05cf\3\2"+ 16287 "\2\2\u05cd\u05cb\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05d0\3\2\2\2\u05cf"+ 16288 "\u05cd\3\2\2\2\u05d0\u05d1\t\4\2\2\u05d1}\3\2\2\2\u05d2\u05d3\7\7\2\2"+ 16289 "\u05d3\u05da\7U\2\2\u05d4\u05d9\5\n\6\2\u05d5\u05d9\7\b\2\2\u05d6\u05d9"+ 16290 "\7\3\2\2\u05d7\u05d9\7\6\2\2\u05d8\u05d4\3\2\2\2\u05d8\u05d5\3\2\2\2\u05d8"+ 16291 "\u05d6\3\2\2\2\u05d8\u05d7\3\2\2\2\u05d9\u05dc\3\2\2\2\u05da\u05d8\3\2"+ 16292 "\2\2\u05da\u05db\3\2\2\2\u05db\u05dd\3\2\2\2\u05dc\u05da\3\2\2\2\u05dd"+ 16293 "\u05de\t\4\2\2\u05de\177\3\2\2\2\u05df\u05e0\7\7\2\2\u05e0\u05e7\7V\2"+ 16294 "\2\u05e1\u05e6\5\n\6\2\u05e2\u05e6\7\b\2\2\u05e3\u05e6\7\3\2\2\u05e4\u05e6"+ 16295 "\7\6\2\2\u05e5\u05e1\3\2\2\2\u05e5\u05e2\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5"+ 16296 "\u05e4\3\2\2\2\u05e6\u05e9\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e7\u05e8\3\2"+ 16297 "\2\2\u05e8\u05ea\3\2\2\2\u05e9\u05e7\3\2\2\2\u05ea\u05eb\t\4\2\2\u05eb"+ 16298 "\u0081\3\2\2\2\u05ec\u05ed\7\7\2\2\u05ed\u05f4\7W\2\2\u05ee\u05f3\5\n"+ 16299 "\6\2\u05ef\u05f3\7\b\2\2\u05f0\u05f3\7\3\2\2\u05f1\u05f3\7\6\2\2\u05f2"+ 16300 "\u05ee\3\2\2\2\u05f2\u05ef\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f1\3\2"+ 16301 "\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5"+ 16302 "\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\t\4\2\2\u05f8\u0083\3\2"+ 16303 "\2\2\u05f9\u05fa\7\7\2\2\u05fa\u0601\7X\2\2\u05fb\u0600\5\n\6\2\u05fc"+ 16304 "\u0600\7\b\2\2\u05fd\u0600\7\3\2\2\u05fe\u0600\7\6\2\2\u05ff\u05fb\3\2"+ 16305 "\2\2\u05ff\u05fc\3\2\2\2\u05ff\u05fd\3\2\2\2\u05ff\u05fe\3\2\2\2\u0600"+ 16306 "\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0604\3\2"+ 16307 "\2\2\u0603\u0601\3\2\2\2\u0604\u0605\t\4\2\2\u0605\u0085\3\2\2\2\u0606"+ 16308 "\u0607\7\7\2\2\u0607\u0608\7;\2\2\u0608\u0609\5\u0088E\2\u0609\u060a\7"+ 16309 "9\2\2\u060a\u060b\bD\1\2\u060b\u0087\3\2\2\2\u060c\u060d\t\5\2\2\u060d"+ 16310 "\u0089\3\2\2\2\u060e\u060f\6F\24\2\u060f\u0617\7\3\2\2\u0610\u0617\5\u0094"+ 16311 "K\2\u0611\u0617\7\5\2\2\u0612\u0617\7\b\2\2\u0613\u0617\5\u0096L\2\u0614"+ 16312 "\u0617\5\u0092J\2\u0615\u0617\5\4\3\2\u0616\u060e\3\2\2\2\u0616\u0610"+ 16313 "\3\2\2\2\u0616\u0611\3\2\2\2\u0616\u0612\3\2\2\2\u0616\u0613\3\2\2\2\u0616"+ 16314 "\u0614\3\2\2\2\u0616\u0615\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u0616\3\2"+ 16315 "\2\2\u0618\u0619\3\2\2\2\u0619\u008b\3\2\2\2\u061a\u061e\7\36\2\2\u061b"+ 16316 "\u061d\t\6\2\2\u061c\u061b\3\2\2\2\u061d\u0620\3\2\2\2\u061e\u061c\3\2"+ 16317 "\2\2\u061e\u061f\3\2\2\2\u061f\u0622\3\2\2\2\u0620\u061e\3\2\2\2\u0621"+ 16318 "\u0623\7 \2\2\u0622\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2"+ 16319 "\2\2\u0624\u0626\7#\2\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626"+ 16320 "\u0628\3\2\2\2\u0627\u0629\5\u008eH\2\u0628\u0627\3\2\2\2\u0628\u0629"+ 16321 "\3\2\2\2\u0629\u0640\3\2\2\2\u062a\u062c\t\6\2\2\u062b\u062a\3\2\2\2\u062c"+ 16322 "\u062d\3\2\2\2\u062d\u062b\3\2\2\2\u062d\u062e\3\2\2\2\u062e\u0630\3\2"+ 16323 "\2\2\u062f\u0631\7 \2\2\u0630\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631"+ 16324 "\u0633\3\2\2\2\u0632\u0634\7#\2\2\u0633\u0632\3\2\2\2\u0633\u0634\3\2"+ 16325 "\2\2\u0634\u0636\3\2\2\2\u0635\u0637\5\u008eH\2\u0636\u0635\3\2\2\2\u0636"+ 16326 "\u0637\3\2\2\2\u0637\u0640\3\2\2\2\u0638\u063a\7 \2\2\u0639\u0638\3\2"+ 16327 "\2\2\u0639\u063a\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063d\7#\2\2\u063c"+ 16328 "\u063e\5\u008eH\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0640"+ 16329 "\3\2\2\2\u063f\u061a\3\2\2\2\u063f\u062b\3\2\2\2\u063f\u0639\3\2\2\2\u0640"+ 16330 "\u008d\3\2\2\2\u0641\u0645\7$\2\2\u0642\u0644\t\7\2\2\u0643\u0642\3\2"+ 16331 "\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646"+ 16332 "\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649\7%\2\2\u0649\u008f\3\2"+ 16333 "\2\2\u064a\u064e\7\t\2\2\u064b\u064d\t\b\2\2\u064c\u064b\3\2\2\2\u064d"+ 16334 "\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f\3\2\2\2\u064f\u0652\3\2"+ 16335 "\2\2\u0650\u064e\3\2\2\2\u0651\u0653\5\u008aF\2\u0652\u0651\3\2\2\2\u0652"+ 16336 "\u0653\3\2\2\2\u0653\u070d\3\2\2\2\u0654\u0658\7\n\2\2\u0655\u0657\t\b"+ 16337 "\2\2\u0656\u0655\3\2\2\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+ 16338 "\u0659\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065b\u065d\5\u008a"+ 16339 "F\2\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u070d\3\2\2\2\u065e"+ 16340 "\u0662\7\13\2\2\u065f\u0661\t\b\2\2\u0660\u065f\3\2\2\2\u0661\u0664\3"+ 16341 "\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0666\3\2\2\2\u0664"+ 16342 "\u0662\3\2\2\2\u0665\u0667\7-\2\2\u0666\u0665\3\2\2\2\u0666\u0667\3\2"+ 16343 "\2\2\u0667\u066b\3\2\2\2\u0668\u066a\t\b\2\2\u0669\u0668\3\2\2\2\u066a"+ 16344 "\u066d\3\2\2\2\u066b\u0669\3\2\2\2\u066b\u066c\3\2\2\2\u066c\u066f\3\2"+ 16345 "\2\2\u066d\u066b\3\2\2\2\u066e\u0670\5\u008aF\2\u066f\u066e\3\2\2\2\u066f"+ 16346 "\u0670\3\2\2\2\u0670\u070d\3\2\2\2\u0671\u0675\7\f\2\2\u0672\u0674\t\b"+ 16347 "\2\2\u0673\u0672\3\2\2\2\u0674\u0677\3\2\2\2\u0675\u0673\3\2\2\2\u0675"+ 16348 "\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0675\3\2\2\2\u0678\u067a\7\33"+ 16349 "\2\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067e\3\2\2\2\u067b"+ 16350 "\u067d\t\b\2\2\u067c\u067b\3\2\2\2\u067d\u0680\3\2\2\2\u067e\u067c\3\2"+ 16351 "\2\2\u067e\u067f\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e\3\2\2\2\u0681"+ 16352 "\u0683\5\u008aF\2\u0682\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u070d"+ 16353 "\3\2\2\2\u0684\u0688\7\r\2\2\u0685\u0687\t\b\2\2\u0686\u0685\3\2\2\2\u0687"+ 16354 "\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068c\3\2"+ 16355 "\2\2\u068a\u0688\3\2\2\2\u068b\u068d\5\u008aF\2\u068c\u068b\3\2\2\2\u068c"+ 16356 "\u068d\3\2\2\2\u068d\u070d\3\2\2\2\u068e\u0692\7\16\2\2\u068f\u0691\t"+ 16357 "\b\2\2\u0690\u068f\3\2\2\2\u0691\u0694\3\2\2\2\u0692\u0690\3\2\2\2\u0692"+ 16358 "\u0693\3\2\2\2\u0693\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695\u0697\5\u008c"+ 16359 "G\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069c\3\2\2\2\u0698"+ 16360 "\u069b\7\35\2\2\u0699\u069b\5\4\3\2\u069a\u0698\3\2\2\2\u069a\u0699\3"+ 16361 "\2\2\2\u069b\u069e\3\2\2\2\u069c\u069a\3\2\2\2\u069c\u069d\3\2\2\2\u069d"+ 16362 "\u06a2\3\2\2\2\u069e\u069c\3\2\2\2\u069f\u06a1\t\b\2\2\u06a0\u069f\3\2"+ 16363 "\2\2\u06a1\u06a4\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3"+ 16364 "\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a5\u06a7\5\u008aF\2\u06a6\u06a5"+ 16365 "\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u070d\3\2\2\2\u06a8\u06ac\7\17\2\2"+ 16366 "\u06a9\u06ab\t\b\2\2\u06aa\u06a9\3\2\2\2\u06ab\u06ae\3\2\2\2\u06ac\u06aa"+ 16367 "\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06b0\3\2\2\2\u06ae\u06ac\3\2\2\2\u06af"+ 16368 "\u06b1\t\t\2\2\u06b0\u06af\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b3\3\2"+ 16369 "\2\2\u06b2\u06b4\5\u008aF\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4"+ 16370 "\u070d\3\2\2\2\u06b5\u06b9\7\21\2\2\u06b6\u06b8\t\b\2\2\u06b7\u06b6\3"+ 16371 "\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba"+ 16372 "\u06bd\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5\u008aF\2\u06bd\u06bc"+ 16373 "\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u070d\3\2\2\2\u06bf\u06c3\7\20\2\2"+ 16374 "\u06c0\u06c2\t\b\2\2\u06c1\u06c0\3\2\2\2\u06c2\u06c5\3\2\2\2\u06c3\u06c1"+ 16375 "\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2\2\2\u06c6"+ 16376 "\u06c8\7)\2\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cc\3\2"+ 16377 "\2\2\u06c9\u06cb\t\b\2\2\u06ca\u06c9\3\2\2\2\u06cb\u06ce\3\2\2\2\u06cc"+ 16378 "\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06d0\3\2\2\2\u06ce\u06cc\3\2"+ 16379 "\2\2\u06cf\u06d1\7+\2\2\u06d0\u06cf\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1"+ 16380 "\u06d5\3\2\2\2\u06d2\u06d4\t\b\2\2\u06d3\u06d2\3\2\2\2\u06d4\u06d7\3\2"+ 16381 "\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d9\3\2\2\2\u06d7"+ 16382 "\u06d5\3\2\2\2\u06d8\u06da\5\u008aF\2\u06d9\u06d8\3\2\2\2\u06d9\u06da"+ 16383 "\3\2\2\2\u06da\u070d\3\2\2\2\u06db\u06df\7\22\2\2\u06dc\u06de\t\b\2\2"+ 16384 "\u06dd\u06dc\3\2\2\2\u06de\u06e1\3\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06e0"+ 16385 "\3\2\2\2\u06e0\u06e3\3\2\2\2\u06e1\u06df\3\2\2\2\u06e2\u06e4\5\u008aF"+ 16386 "\2\u06e3\u06e2\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u070d\3\2\2\2\u06e5\u06e9"+ 16387 "\7\23\2\2\u06e6\u06e8\t\b\2\2\u06e7\u06e6\3\2\2\2\u06e8\u06eb\3\2\2\2"+ 16388 "\u06e9\u06e7\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb\u06e9"+ 16389 "\3\2\2\2\u06ec\u06ee\7-\2\2\u06ed\u06ec\3\2\2\2\u06ed\u06ee\3\2\2\2\u06ee"+ 16390 "\u06f2\3\2\2\2\u06ef\u06f1\t\b\2\2\u06f0\u06ef\3\2\2\2\u06f1\u06f4\3\2"+ 16391 "\2\2\u06f2\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f6\3\2\2\2\u06f4"+ 16392 "\u06f2\3\2\2\2\u06f5\u06f7\5\u008aF\2\u06f6\u06f5\3\2\2\2\u06f6\u06f7"+ 16393 "\3\2\2\2\u06f7\u070d\3\2\2\2\u06f8\u06fc\7\24\2\2\u06f9\u06fb\t\b\2\2"+ 16394 "\u06fa\u06f9\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd"+ 16395 "\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06ff\u0701\5\u008aF"+ 16396 "\2\u0700\u06ff\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u070d\3\2\2\2\u0702\u0706"+ 16397 "\7\27\2\2\u0703\u0705\t\b\2\2\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2"+ 16398 "\u0706\u0704\3\2\2\2\u0706\u0707\3\2\2\2\u0707\u070a\3\2\2\2\u0708\u0706"+ 16399 "\3\2\2\2\u0709\u070b\5\u008aF\2\u070a\u0709\3\2\2\2\u070a\u070b\3\2\2"+ 16400 "\2\u070b\u070d\3\2\2\2\u070c\u064a\3\2\2\2\u070c\u0654\3\2\2\2\u070c\u065e"+ 16401 "\3\2\2\2\u070c\u0671\3\2\2\2\u070c\u0684\3\2\2\2\u070c\u068e\3\2\2\2\u070c"+ 16402 "\u06a8\3\2\2\2\u070c\u06b5\3\2\2\2\u070c\u06bf\3\2\2\2\u070c\u06db\3\2"+ 16403 "\2\2\u070c\u06e5\3\2\2\2\u070c\u06f8\3\2\2\2\u070c\u0702\3\2\2\2\u070d"+ 16404 "\u0091\3\2\2\2\u070e\u075b\7\25\2\2\u070f\u0716\7/\2\2\u0710\u0715\7\6"+ 16405 "\2\2\u0711\u0715\7\b\2\2\u0712\u0715\7\3\2\2\u0713\u0715\5\u0096L\2\u0714"+ 16406 "\u0710\3\2\2\2\u0714\u0711\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0713\3\2"+ 16407 "\2\2\u0715\u0718\3\2\2\2\u0716\u0714\3\2\2\2\u0716\u0717\3\2\2\2\u0717"+ 16408 "\u075c\3\2\2\2\u0718\u0716\3\2\2\2\u0719\u071d\7\60\2\2\u071a\u071c\t"+ 16409 "\2\2\2\u071b\u071a\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2\2\2\u071d"+ 16410 "\u071e\3\2\2\2\u071e\u075c\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0724\7\61"+ 16411 "\2\2\u0721\u0723\t\2\2\2\u0722\u0721\3\2\2\2\u0723\u0726\3\2\2\2\u0724"+ 16412 "\u0722\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u075c\3\2\2\2\u0726\u0724\3\2"+ 16413 "\2\2\u0727\u072b\7\62\2\2\u0728\u072a\t\2\2\2\u0729\u0728\3\2\2\2\u072a"+ 16414 "\u072d\3\2\2\2\u072b\u0729\3\2\2\2\u072b\u072c\3\2\2\2\u072c\u072e\3\2"+ 16415 "\2\2\u072d\u072b\3\2\2\2\u072e\u0730\5\u008cG\2\u072f\u0731\5\u008aF\2"+ 16416 "\u0730\u072f\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u075c\3\2\2\2\u0732\u0736"+ 16417 "\7\63\2\2\u0733\u0735\t\2\2\2\u0734\u0733\3\2\2\2\u0735\u0738\3\2\2\2"+ 16418 "\u0736\u0734\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u0739\3\2\2\2\u0738\u0736"+ 16419 "\3\2\2\2\u0739\u073b\5\u008cG\2\u073a\u073c\5\u008aF\2\u073b\u073a\3\2"+ 16420 "\2\2\u073b\u073c\3\2\2\2\u073c\u075c\3\2\2\2\u073d\u0744\7\64\2\2\u073e"+ 16421 "\u0743\7\6\2\2\u073f\u0743\7\b\2\2\u0740\u0743\7\3\2\2\u0741\u0743\5\u0096"+ 16422 "L\2\u0742\u073e\3\2\2\2\u0742\u073f\3\2\2\2\u0742\u0740\3\2\2\2\u0742"+ 16423 "\u0741\3\2\2\2\u0743\u0746\3\2\2\2\u0744\u0742\3\2\2\2\u0744\u0745\3\2"+ 16424 "\2\2\u0745\u075c\3\2\2\2\u0746\u0744\3\2\2\2\u0747\u074b\7\65\2\2\u0748"+ 16425 "\u074a\t\2\2\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749\3\2"+ 16426 "\2\2\u074b\u074c\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+ 16427 "\u0750\5\u008cG\2\u074f\u074e\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u075c"+ 16428 "\3\2\2\2\u0751\u0755\7\27\2\2\u0752\u0754\t\2\2\2\u0753\u0752\3\2\2\2"+ 16429 "\u0754\u0757\3\2\2\2\u0755\u0753\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0759"+ 16430 "\3\2\2\2\u0757\u0755\3\2\2\2\u0758\u075a\5\u008aF\2\u0759\u0758\3\2\2"+ 16431 "\2\u0759\u075a\3\2\2\2\u075a\u075c\3\2\2\2\u075b\u070f\3\2\2\2\u075b\u0719"+ 16432 "\3\2\2\2\u075b\u0720\3\2\2\2\u075b\u0727\3\2\2\2\u075b\u0732\3\2\2\2\u075b"+ 16433 "\u073d\3\2\2\2\u075b\u0747\3\2\2\2\u075b\u0751\3\2\2\2\u075c\u075d\3\2"+ 16434 "\2\2\u075d\u075e\7\26\2\2\u075e\u0093\3\2\2\2\u075f\u0765\7\4\2\2\u0760"+ 16435 "\u0764\5\u0096L\2\u0761\u0764\7\b\2\2\u0762\u0764\7\3\2\2\u0763\u0760"+ 16436 "\3\2\2\2\u0763\u0761\3\2\2\2\u0763\u0762\3\2\2\2\u0764\u0767\3\2\2\2\u0765"+ 16437 "\u0763\3\2\2\2\u0765\u0766\3\2\2\2\u0766\u0768\3\2\2\2\u0767\u0765\3\2"+ 16438 "\2\2\u0768\u0769\7]\2\2\u0769\u0095\3\2\2\2\u076a\u076b\t\n\2\2\u076b"+ 16439 "\u076d\bL\1\2\u076c\u076a\3\2\2\2\u076d\u076e\3\2\2\2\u076e\u076c\3\2"+ 16440 "\2\2\u076e\u076f\3\2\2\2\u076f\u0097\3\2\2\2\u00c5\u00a0\u00a2\u00a6\u00ab"+ 16441 "\u00b1\u00e5\u00ed\u00ef\u00fa\u0103\u010a\u0110\u011b\u011d\u012b\u012d"+ 16442 "\u0132\u013a\u013c\u0147\u0172\u0174\u017f\u0181\u018c\u01b7\u01b9\u01c4"+ 16443 "\u01c6\u01d1\u01fc\u01fe\u0209\u020b\u0216\u0241\u0243\u024e\u0250\u025b"+ 16444 "\u0286\u0288\u0293\u0295\u02a0\u02cb\u02cd\u02d8\u02da\u02e5\u0310\u0312"+ 16445 "\u031d\u031f\u032a\u0355\u0357\u0362\u0364\u036f\u039a\u039c\u03a7\u03a9"+ 16446 "\u03b4\u03df\u03e1\u03ec\u03ee\u03f9\u0424\u0426\u0431\u0433\u043e\u0469"+ 16447 "\u046b\u0476\u0478\u0483\u04ae\u04b0\u04bb\u04bd\u04c8\u04f3\u04f5\u0500"+ 16448 "\u0502\u050d\u0538\u053a\u054e\u0556\u0558\u0563\u0565\u0570\u0572\u057d"+ 16449 "\u057f\u058a\u058c\u0597\u0599\u05a4\u05a6\u05b1\u05b3\u05be\u05c0\u05cb"+ 16450 "\u05cd\u05d8\u05da\u05e5\u05e7\u05f2\u05f4\u05ff\u0601\u0616\u0618\u061e"+ 16451 "\u0622\u0625\u0628\u062d\u0630\u0633\u0636\u0639\u063d\u063f\u0645\u064e"+ 16452 "\u0652\u0658\u065c\u0662\u0666\u066b\u066f\u0675\u0679\u067e\u0682\u0688"+ 16453 "\u068c\u0692\u0696\u069a\u069c\u06a2\u06a6\u06ac\u06b0\u06b3\u06b9\u06bd"+ 16454 "\u06c3\u06c7\u06cc\u06d0\u06d5\u06d9\u06df\u06e3\u06e9\u06ed\u06f2\u06f6"+ 16455 "\u06fc\u0700\u0706\u070a\u070c\u0714\u0716\u071d\u0724\u072b\u0730\u0736"+ 16456 "\u073b\u0742\u0744\u074b\u074f\u0755\u0759\u075b\u0763\u0765\u076e"; 16457 public static final ATN _ATN = 16458 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 16459 static { 16460 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; 16461 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { 16462 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); 16463 } 16464 } 16465}