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 196 public static class JavadocContext extends ParserRuleContext { 197 public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); } 198 public List<HtmlElementContext> htmlElement() { 199 return getRuleContexts(HtmlElementContext.class); 200 } 201 public HtmlElementContext htmlElement(int i) { 202 return getRuleContext(HtmlElementContext.class,i); 203 } 204 public List<HtmlCommentContext> htmlComment() { 205 return getRuleContexts(HtmlCommentContext.class); 206 } 207 public HtmlCommentContext htmlComment(int i) { 208 return getRuleContext(HtmlCommentContext.class,i); 209 } 210 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 211 public TerminalNode CDATA(int i) { 212 return getToken(JavadocParser.CDATA, i); 213 } 214 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 215 public TerminalNode NEWLINE(int i) { 216 return getToken(JavadocParser.NEWLINE, i); 217 } 218 public List<TextContext> text() { 219 return getRuleContexts(TextContext.class); 220 } 221 public TextContext text(int i) { 222 return getRuleContext(TextContext.class,i); 223 } 224 public List<JavadocInlineTagContext> javadocInlineTag() { 225 return getRuleContexts(JavadocInlineTagContext.class); 226 } 227 public JavadocInlineTagContext javadocInlineTag(int i) { 228 return getRuleContext(JavadocInlineTagContext.class,i); 229 } 230 public List<JavadocTagContext> javadocTag() { 231 return getRuleContexts(JavadocTagContext.class); 232 } 233 public JavadocTagContext javadocTag(int i) { 234 return getRuleContext(JavadocTagContext.class,i); 235 } 236 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 237 public TerminalNode LEADING_ASTERISK(int i) { 238 return getToken(JavadocParser.LEADING_ASTERISK, i); 239 } 240 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 241 public TerminalNode WS(int i) { 242 return getToken(JavadocParser.WS, i); 243 } 244 public JavadocContext(ParserRuleContext parent, int invokingState) { 245 super(parent, invokingState); 246 } 247 @Override public int getRuleIndex() { return RULE_javadoc; } 248 @Override 249 public void enterRule(ParseTreeListener listener) { 250 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadoc(this); 251 } 252 @Override 253 public void exitRule(ParseTreeListener listener) { 254 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadoc(this); 255 } 256 @Override 257 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 258 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadoc(this); 259 else return visitor.visitChildren(this); 260 } 261 } 262 263 public final JavadocContext javadoc() throws RecognitionException { 264 JavadocContext _localctx = new JavadocContext(_ctx, getState()); 265 enterRule(_localctx, 0, RULE_javadoc); 266 int _la; 267 try { 268 int _alt; 269 enterOuterAlt(_localctx, 1); 270 { 271 setState(160); 272 _errHandler.sync(this); 273 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 274 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 275 if ( _alt==1 ) { 276 { 277 setState(158); 278 _errHandler.sync(this); 279 switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { 280 case 1: 281 { 282 setState(150); 283 htmlElement(); 284 } 285 break; 286 case 2: 287 { 288 { 289 setState(151); 290 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 291 setState(152); 292 match(LEADING_ASTERISK); 293 } 294 } 295 break; 296 case 3: 297 { 298 setState(153); 299 htmlComment(); 300 } 301 break; 302 case 4: 303 { 304 setState(154); 305 match(CDATA); 306 } 307 break; 308 case 5: 309 { 310 setState(155); 311 match(NEWLINE); 312 } 313 break; 314 case 6: 315 { 316 setState(156); 317 text(); 318 } 319 break; 320 case 7: 321 { 322 setState(157); 323 javadocInlineTag(); 324 } 325 break; 326 } 327 } 328 } 329 setState(162); 330 _errHandler.sync(this); 331 _alt = getInterpreter().adaptivePredict(_input,1,_ctx); 332 } 333 setState(175); 334 _errHandler.sync(this); 335 _la = _input.LA(1); 336 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)) { 337 { 338 { 339 setState(164); 340 _la = _input.LA(1); 341 if (_la==LEADING_ASTERISK) { 342 { 343 setState(163); 344 match(LEADING_ASTERISK); 345 } 346 } 347 348 setState(169); 349 _errHandler.sync(this); 350 _la = _input.LA(1); 351 while (_la==WS) { 352 { 353 { 354 setState(166); 355 match(WS); 356 } 357 } 358 setState(171); 359 _errHandler.sync(this); 360 _la = _input.LA(1); 361 } 362 setState(172); 363 javadocTag(); 364 } 365 } 366 setState(177); 367 _errHandler.sync(this); 368 _la = _input.LA(1); 369 } 370 setState(178); 371 match(EOF); 372 } 373 } 374 catch (RecognitionException re) { 375 _localctx.exception = re; 376 _errHandler.reportError(this, re); 377 _errHandler.recover(this, re); 378 } 379 finally { 380 exitRule(); 381 } 382 return _localctx; 383 } 384 385 public static class HtmlElementContext extends ParserRuleContext { 386 public HtmlTagContext htmlTag() { 387 return getRuleContext(HtmlTagContext.class,0); 388 } 389 public SingletonElementContext singletonElement() { 390 return getRuleContext(SingletonElementContext.class,0); 391 } 392 public ParagraphContext paragraph() { 393 return getRuleContext(ParagraphContext.class,0); 394 } 395 public LiContext li() { 396 return getRuleContext(LiContext.class,0); 397 } 398 public TrContext tr() { 399 return getRuleContext(TrContext.class,0); 400 } 401 public TdContext td() { 402 return getRuleContext(TdContext.class,0); 403 } 404 public ThContext th() { 405 return getRuleContext(ThContext.class,0); 406 } 407 public BodyContext body() { 408 return getRuleContext(BodyContext.class,0); 409 } 410 public ColgroupContext colgroup() { 411 return getRuleContext(ColgroupContext.class,0); 412 } 413 public DdContext dd() { 414 return getRuleContext(DdContext.class,0); 415 } 416 public DtContext dt() { 417 return getRuleContext(DtContext.class,0); 418 } 419 public HeadContext head() { 420 return getRuleContext(HeadContext.class,0); 421 } 422 public HtmlContext html() { 423 return getRuleContext(HtmlContext.class,0); 424 } 425 public OptionContext option() { 426 return getRuleContext(OptionContext.class,0); 427 } 428 public TbodyContext tbody() { 429 return getRuleContext(TbodyContext.class,0); 430 } 431 public TheadContext thead() { 432 return getRuleContext(TheadContext.class,0); 433 } 434 public TfootContext tfoot() { 435 return getRuleContext(TfootContext.class,0); 436 } 437 public PTagOpenContext pTagOpen() { 438 return getRuleContext(PTagOpenContext.class,0); 439 } 440 public LiTagOpenContext liTagOpen() { 441 return getRuleContext(LiTagOpenContext.class,0); 442 } 443 public TrTagOpenContext trTagOpen() { 444 return getRuleContext(TrTagOpenContext.class,0); 445 } 446 public TdTagOpenContext tdTagOpen() { 447 return getRuleContext(TdTagOpenContext.class,0); 448 } 449 public ThTagOpenContext thTagOpen() { 450 return getRuleContext(ThTagOpenContext.class,0); 451 } 452 public BodyTagOpenContext bodyTagOpen() { 453 return getRuleContext(BodyTagOpenContext.class,0); 454 } 455 public ColgroupTagOpenContext colgroupTagOpen() { 456 return getRuleContext(ColgroupTagOpenContext.class,0); 457 } 458 public DdTagOpenContext ddTagOpen() { 459 return getRuleContext(DdTagOpenContext.class,0); 460 } 461 public DtTagOpenContext dtTagOpen() { 462 return getRuleContext(DtTagOpenContext.class,0); 463 } 464 public HeadTagOpenContext headTagOpen() { 465 return getRuleContext(HeadTagOpenContext.class,0); 466 } 467 public HtmlTagOpenContext htmlTagOpen() { 468 return getRuleContext(HtmlTagOpenContext.class,0); 469 } 470 public OptionTagOpenContext optionTagOpen() { 471 return getRuleContext(OptionTagOpenContext.class,0); 472 } 473 public TbodyTagOpenContext tbodyTagOpen() { 474 return getRuleContext(TbodyTagOpenContext.class,0); 475 } 476 public TheadTagOpenContext theadTagOpen() { 477 return getRuleContext(TheadTagOpenContext.class,0); 478 } 479 public TfootTagOpenContext tfootTagOpen() { 480 return getRuleContext(TfootTagOpenContext.class,0); 481 } 482 public PTagCloseContext pTagClose() { 483 return getRuleContext(PTagCloseContext.class,0); 484 } 485 public LiTagCloseContext liTagClose() { 486 return getRuleContext(LiTagCloseContext.class,0); 487 } 488 public TrTagCloseContext trTagClose() { 489 return getRuleContext(TrTagCloseContext.class,0); 490 } 491 public TdTagCloseContext tdTagClose() { 492 return getRuleContext(TdTagCloseContext.class,0); 493 } 494 public ThTagCloseContext thTagClose() { 495 return getRuleContext(ThTagCloseContext.class,0); 496 } 497 public BodyTagCloseContext bodyTagClose() { 498 return getRuleContext(BodyTagCloseContext.class,0); 499 } 500 public ColgroupTagCloseContext colgroupTagClose() { 501 return getRuleContext(ColgroupTagCloseContext.class,0); 502 } 503 public DdTagCloseContext ddTagClose() { 504 return getRuleContext(DdTagCloseContext.class,0); 505 } 506 public DtTagCloseContext dtTagClose() { 507 return getRuleContext(DtTagCloseContext.class,0); 508 } 509 public HeadTagCloseContext headTagClose() { 510 return getRuleContext(HeadTagCloseContext.class,0); 511 } 512 public HtmlTagCloseContext htmlTagClose() { 513 return getRuleContext(HtmlTagCloseContext.class,0); 514 } 515 public OptionTagCloseContext optionTagClose() { 516 return getRuleContext(OptionTagCloseContext.class,0); 517 } 518 public TbodyTagCloseContext tbodyTagClose() { 519 return getRuleContext(TbodyTagCloseContext.class,0); 520 } 521 public TheadTagCloseContext theadTagClose() { 522 return getRuleContext(TheadTagCloseContext.class,0); 523 } 524 public TfootTagCloseContext tfootTagClose() { 525 return getRuleContext(TfootTagCloseContext.class,0); 526 } 527 public HtmlElementContext(ParserRuleContext parent, int invokingState) { 528 super(parent, invokingState); 529 } 530 @Override public int getRuleIndex() { return RULE_htmlElement; } 531 @Override 532 public void enterRule(ParseTreeListener listener) { 533 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElement(this); 534 } 535 @Override 536 public void exitRule(ParseTreeListener listener) { 537 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElement(this); 538 } 539 @Override 540 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 541 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElement(this); 542 else return visitor.visitChildren(this); 543 } 544 } 545 546 public final HtmlElementContext htmlElement() throws RecognitionException { 547 HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState()); 548 enterRule(_localctx, 2, RULE_htmlElement); 549 try { 550 setState(227); 551 _errHandler.sync(this); 552 switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { 553 case 1: 554 enterOuterAlt(_localctx, 1); 555 { 556 setState(180); 557 htmlTag(); 558 } 559 break; 560 case 2: 561 enterOuterAlt(_localctx, 2); 562 { 563 setState(181); 564 singletonElement(); 565 } 566 break; 567 case 3: 568 enterOuterAlt(_localctx, 3); 569 { 570 setState(182); 571 paragraph(); 572 } 573 break; 574 case 4: 575 enterOuterAlt(_localctx, 4); 576 { 577 setState(183); 578 li(); 579 } 580 break; 581 case 5: 582 enterOuterAlt(_localctx, 5); 583 { 584 setState(184); 585 tr(); 586 } 587 break; 588 case 6: 589 enterOuterAlt(_localctx, 6); 590 { 591 setState(185); 592 td(); 593 } 594 break; 595 case 7: 596 enterOuterAlt(_localctx, 7); 597 { 598 setState(186); 599 th(); 600 } 601 break; 602 case 8: 603 enterOuterAlt(_localctx, 8); 604 { 605 setState(187); 606 body(); 607 } 608 break; 609 case 9: 610 enterOuterAlt(_localctx, 9); 611 { 612 setState(188); 613 colgroup(); 614 } 615 break; 616 case 10: 617 enterOuterAlt(_localctx, 10); 618 { 619 setState(189); 620 dd(); 621 } 622 break; 623 case 11: 624 enterOuterAlt(_localctx, 11); 625 { 626 setState(190); 627 dt(); 628 } 629 break; 630 case 12: 631 enterOuterAlt(_localctx, 12); 632 { 633 setState(191); 634 head(); 635 } 636 break; 637 case 13: 638 enterOuterAlt(_localctx, 13); 639 { 640 setState(192); 641 html(); 642 } 643 break; 644 case 14: 645 enterOuterAlt(_localctx, 14); 646 { 647 setState(193); 648 option(); 649 } 650 break; 651 case 15: 652 enterOuterAlt(_localctx, 15); 653 { 654 setState(194); 655 tbody(); 656 } 657 break; 658 case 16: 659 enterOuterAlt(_localctx, 16); 660 { 661 setState(195); 662 thead(); 663 } 664 break; 665 case 17: 666 enterOuterAlt(_localctx, 17); 667 { 668 setState(196); 669 tfoot(); 670 } 671 break; 672 case 18: 673 enterOuterAlt(_localctx, 18); 674 { 675 setState(197); 676 pTagOpen(); 677 } 678 break; 679 case 19: 680 enterOuterAlt(_localctx, 19); 681 { 682 setState(198); 683 liTagOpen(); 684 } 685 break; 686 case 20: 687 enterOuterAlt(_localctx, 20); 688 { 689 setState(199); 690 trTagOpen(); 691 } 692 break; 693 case 21: 694 enterOuterAlt(_localctx, 21); 695 { 696 setState(200); 697 tdTagOpen(); 698 } 699 break; 700 case 22: 701 enterOuterAlt(_localctx, 22); 702 { 703 setState(201); 704 thTagOpen(); 705 } 706 break; 707 case 23: 708 enterOuterAlt(_localctx, 23); 709 { 710 setState(202); 711 bodyTagOpen(); 712 } 713 break; 714 case 24: 715 enterOuterAlt(_localctx, 24); 716 { 717 setState(203); 718 colgroupTagOpen(); 719 } 720 break; 721 case 25: 722 enterOuterAlt(_localctx, 25); 723 { 724 setState(204); 725 ddTagOpen(); 726 } 727 break; 728 case 26: 729 enterOuterAlt(_localctx, 26); 730 { 731 setState(205); 732 dtTagOpen(); 733 } 734 break; 735 case 27: 736 enterOuterAlt(_localctx, 27); 737 { 738 setState(206); 739 headTagOpen(); 740 } 741 break; 742 case 28: 743 enterOuterAlt(_localctx, 28); 744 { 745 setState(207); 746 htmlTagOpen(); 747 } 748 break; 749 case 29: 750 enterOuterAlt(_localctx, 29); 751 { 752 setState(208); 753 optionTagOpen(); 754 } 755 break; 756 case 30: 757 enterOuterAlt(_localctx, 30); 758 { 759 setState(209); 760 tbodyTagOpen(); 761 } 762 break; 763 case 31: 764 enterOuterAlt(_localctx, 31); 765 { 766 setState(210); 767 theadTagOpen(); 768 } 769 break; 770 case 32: 771 enterOuterAlt(_localctx, 32); 772 { 773 setState(211); 774 tfootTagOpen(); 775 } 776 break; 777 case 33: 778 enterOuterAlt(_localctx, 33); 779 { 780 setState(212); 781 pTagClose(); 782 } 783 break; 784 case 34: 785 enterOuterAlt(_localctx, 34); 786 { 787 setState(213); 788 liTagClose(); 789 } 790 break; 791 case 35: 792 enterOuterAlt(_localctx, 35); 793 { 794 setState(214); 795 trTagClose(); 796 } 797 break; 798 case 36: 799 enterOuterAlt(_localctx, 36); 800 { 801 setState(215); 802 tdTagClose(); 803 } 804 break; 805 case 37: 806 enterOuterAlt(_localctx, 37); 807 { 808 setState(216); 809 thTagClose(); 810 } 811 break; 812 case 38: 813 enterOuterAlt(_localctx, 38); 814 { 815 setState(217); 816 bodyTagClose(); 817 } 818 break; 819 case 39: 820 enterOuterAlt(_localctx, 39); 821 { 822 setState(218); 823 colgroupTagClose(); 824 } 825 break; 826 case 40: 827 enterOuterAlt(_localctx, 40); 828 { 829 setState(219); 830 ddTagClose(); 831 } 832 break; 833 case 41: 834 enterOuterAlt(_localctx, 41); 835 { 836 setState(220); 837 dtTagClose(); 838 } 839 break; 840 case 42: 841 enterOuterAlt(_localctx, 42); 842 { 843 setState(221); 844 headTagClose(); 845 } 846 break; 847 case 43: 848 enterOuterAlt(_localctx, 43); 849 { 850 setState(222); 851 htmlTagClose(); 852 } 853 break; 854 case 44: 855 enterOuterAlt(_localctx, 44); 856 { 857 setState(223); 858 optionTagClose(); 859 } 860 break; 861 case 45: 862 enterOuterAlt(_localctx, 45); 863 { 864 setState(224); 865 tbodyTagClose(); 866 } 867 break; 868 case 46: 869 enterOuterAlt(_localctx, 46); 870 { 871 setState(225); 872 theadTagClose(); 873 } 874 break; 875 case 47: 876 enterOuterAlt(_localctx, 47); 877 { 878 setState(226); 879 tfootTagClose(); 880 } 881 break; 882 } 883 } 884 catch (RecognitionException re) { 885 _localctx.exception = re; 886 _errHandler.reportError(this, re); 887 _errHandler.recover(this, re); 888 } 889 finally { 890 exitRule(); 891 } 892 return _localctx; 893 } 894 895 public static class HtmlElementOpenContext extends ParserRuleContext { 896 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 897 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 898 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 899 public List<AttributeContext> attribute() { 900 return getRuleContexts(AttributeContext.class); 901 } 902 public AttributeContext attribute(int i) { 903 return getRuleContext(AttributeContext.class,i); 904 } 905 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 906 public TerminalNode NEWLINE(int i) { 907 return getToken(JavadocParser.NEWLINE, i); 908 } 909 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 910 public TerminalNode LEADING_ASTERISK(int i) { 911 return getToken(JavadocParser.LEADING_ASTERISK, i); 912 } 913 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 914 public TerminalNode WS(int i) { 915 return getToken(JavadocParser.WS, i); 916 } 917 public HtmlElementOpenContext(ParserRuleContext parent, int invokingState) { 918 super(parent, invokingState); 919 } 920 @Override public int getRuleIndex() { return RULE_htmlElementOpen; } 921 @Override 922 public void enterRule(ParseTreeListener listener) { 923 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementOpen(this); 924 } 925 @Override 926 public void exitRule(ParseTreeListener listener) { 927 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementOpen(this); 928 } 929 @Override 930 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 931 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementOpen(this); 932 else return visitor.visitChildren(this); 933 } 934 } 935 936 public final HtmlElementOpenContext htmlElementOpen() throws RecognitionException { 937 HtmlElementOpenContext _localctx = new HtmlElementOpenContext(_ctx, getState()); 938 enterRule(_localctx, 4, RULE_htmlElementOpen); 939 int _la; 940 try { 941 enterOuterAlt(_localctx, 1); 942 { 943 setState(229); 944 match(OPEN); 945 setState(230); 946 match(HTML_TAG_NAME); 947 setState(237); 948 _errHandler.sync(this); 949 _la = _input.LA(1); 950 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 951 { 952 setState(235); 953 switch (_input.LA(1)) { 954 case HTML_TAG_NAME: 955 { 956 setState(231); 957 attribute(); 958 } 959 break; 960 case NEWLINE: 961 { 962 setState(232); 963 match(NEWLINE); 964 } 965 break; 966 case LEADING_ASTERISK: 967 { 968 setState(233); 969 match(LEADING_ASTERISK); 970 } 971 break; 972 case WS: 973 { 974 setState(234); 975 match(WS); 976 } 977 break; 978 default: 979 throw new NoViableAltException(this); 980 } 981 } 982 setState(239); 983 _errHandler.sync(this); 984 _la = _input.LA(1); 985 } 986 setState(240); 987 match(CLOSE); 988 } 989 } 990 catch (RecognitionException re) { 991 _localctx.exception = re; 992 _errHandler.reportError(this, re); 993 _errHandler.recover(this, re); 994 } 995 finally { 996 exitRule(); 997 } 998 return _localctx; 999 } 1000 1001 public static class HtmlElementCloseContext extends ParserRuleContext { 1002 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1003 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1004 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 1005 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1006 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1007 public TerminalNode NEWLINE(int i) { 1008 return getToken(JavadocParser.NEWLINE, i); 1009 } 1010 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1011 public TerminalNode LEADING_ASTERISK(int i) { 1012 return getToken(JavadocParser.LEADING_ASTERISK, i); 1013 } 1014 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1015 public TerminalNode WS(int i) { 1016 return getToken(JavadocParser.WS, i); 1017 } 1018 public HtmlElementCloseContext(ParserRuleContext parent, int invokingState) { 1019 super(parent, invokingState); 1020 } 1021 @Override public int getRuleIndex() { return RULE_htmlElementClose; } 1022 @Override 1023 public void enterRule(ParseTreeListener listener) { 1024 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlElementClose(this); 1025 } 1026 @Override 1027 public void exitRule(ParseTreeListener listener) { 1028 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlElementClose(this); 1029 } 1030 @Override 1031 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1032 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementClose(this); 1033 else return visitor.visitChildren(this); 1034 } 1035 } 1036 1037 public final HtmlElementCloseContext htmlElementClose() throws RecognitionException { 1038 HtmlElementCloseContext _localctx = new HtmlElementCloseContext(_ctx, getState()); 1039 enterRule(_localctx, 6, RULE_htmlElementClose); 1040 int _la; 1041 try { 1042 enterOuterAlt(_localctx, 1); 1043 { 1044 setState(242); 1045 match(OPEN); 1046 setState(243); 1047 match(SLASH); 1048 setState(244); 1049 match(HTML_TAG_NAME); 1050 setState(248); 1051 _errHandler.sync(this); 1052 _la = _input.LA(1); 1053 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1054 { 1055 { 1056 setState(245); 1057 _la = _input.LA(1); 1058 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1059 _errHandler.recoverInline(this); 1060 } else { 1061 consume(); 1062 } 1063 } 1064 } 1065 setState(250); 1066 _errHandler.sync(this); 1067 _la = _input.LA(1); 1068 } 1069 setState(251); 1070 match(CLOSE); 1071 } 1072 } 1073 catch (RecognitionException re) { 1074 _localctx.exception = re; 1075 _errHandler.reportError(this, re); 1076 _errHandler.recover(this, re); 1077 } 1078 finally { 1079 exitRule(); 1080 } 1081 return _localctx; 1082 } 1083 1084 public static class AttributeContext extends ParserRuleContext { 1085 public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); } 1086 public TerminalNode HTML_TAG_NAME(int i) { 1087 return getToken(JavadocParser.HTML_TAG_NAME, i); 1088 } 1089 public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); } 1090 public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); } 1091 public TextContext text() { 1092 return getRuleContext(TextContext.class,0); 1093 } 1094 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1095 public TerminalNode NEWLINE(int i) { 1096 return getToken(JavadocParser.NEWLINE, i); 1097 } 1098 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1099 public TerminalNode LEADING_ASTERISK(int i) { 1100 return getToken(JavadocParser.LEADING_ASTERISK, i); 1101 } 1102 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1103 public TerminalNode WS(int i) { 1104 return getToken(JavadocParser.WS, i); 1105 } 1106 public AttributeContext(ParserRuleContext parent, int invokingState) { 1107 super(parent, invokingState); 1108 } 1109 @Override public int getRuleIndex() { return RULE_attribute; } 1110 @Override 1111 public void enterRule(ParseTreeListener listener) { 1112 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAttribute(this); 1113 } 1114 @Override 1115 public void exitRule(ParseTreeListener listener) { 1116 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAttribute(this); 1117 } 1118 @Override 1119 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1120 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAttribute(this); 1121 else return visitor.visitChildren(this); 1122 } 1123 } 1124 1125 public final AttributeContext attribute() throws RecognitionException { 1126 AttributeContext _localctx = new AttributeContext(_ctx, getState()); 1127 enterRule(_localctx, 8, RULE_attribute); 1128 int _la; 1129 try { 1130 int _alt; 1131 enterOuterAlt(_localctx, 1); 1132 { 1133 setState(253); 1134 match(HTML_TAG_NAME); 1135 setState(257); 1136 _errHandler.sync(this); 1137 _la = _input.LA(1); 1138 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1139 { 1140 { 1141 setState(254); 1142 _la = _input.LA(1); 1143 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1144 _errHandler.recoverInline(this); 1145 } else { 1146 consume(); 1147 } 1148 } 1149 } 1150 setState(259); 1151 _errHandler.sync(this); 1152 _la = _input.LA(1); 1153 } 1154 setState(260); 1155 match(EQUALS); 1156 setState(264); 1157 _errHandler.sync(this); 1158 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1159 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1160 if ( _alt==1 ) { 1161 { 1162 { 1163 setState(261); 1164 _la = _input.LA(1); 1165 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1166 _errHandler.recoverInline(this); 1167 } else { 1168 consume(); 1169 } 1170 } 1171 } 1172 } 1173 setState(266); 1174 _errHandler.sync(this); 1175 _alt = getInterpreter().adaptivePredict(_input,10,_ctx); 1176 } 1177 setState(270); 1178 switch (_input.LA(1)) { 1179 case ATTR_VALUE: 1180 { 1181 setState(267); 1182 match(ATTR_VALUE); 1183 } 1184 break; 1185 case WS: 1186 case CHAR: 1187 { 1188 setState(268); 1189 text(); 1190 } 1191 break; 1192 case HTML_TAG_NAME: 1193 { 1194 setState(269); 1195 match(HTML_TAG_NAME); 1196 } 1197 break; 1198 default: 1199 throw new NoViableAltException(this); 1200 } 1201 } 1202 } 1203 catch (RecognitionException re) { 1204 _localctx.exception = re; 1205 _errHandler.reportError(this, re); 1206 _errHandler.recover(this, re); 1207 } 1208 finally { 1209 exitRule(); 1210 } 1211 return _localctx; 1212 } 1213 1214 public static class HtmlTagContext extends ParserRuleContext { 1215 public HtmlElementOpenContext htmlElementOpen; 1216 public HtmlElementOpenContext htmlElementOpen() { 1217 return getRuleContext(HtmlElementOpenContext.class,0); 1218 } 1219 public HtmlElementCloseContext htmlElementClose() { 1220 return getRuleContext(HtmlElementCloseContext.class,0); 1221 } 1222 public List<HtmlElementContext> htmlElement() { 1223 return getRuleContexts(HtmlElementContext.class); 1224 } 1225 public HtmlElementContext htmlElement(int i) { 1226 return getRuleContext(HtmlElementContext.class,i); 1227 } 1228 public List<HtmlCommentContext> htmlComment() { 1229 return getRuleContexts(HtmlCommentContext.class); 1230 } 1231 public HtmlCommentContext htmlComment(int i) { 1232 return getRuleContext(HtmlCommentContext.class,i); 1233 } 1234 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1235 public TerminalNode CDATA(int i) { 1236 return getToken(JavadocParser.CDATA, i); 1237 } 1238 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1239 public TerminalNode NEWLINE(int i) { 1240 return getToken(JavadocParser.NEWLINE, i); 1241 } 1242 public List<TextContext> text() { 1243 return getRuleContexts(TextContext.class); 1244 } 1245 public TextContext text(int i) { 1246 return getRuleContext(TextContext.class,i); 1247 } 1248 public List<JavadocInlineTagContext> javadocInlineTag() { 1249 return getRuleContexts(JavadocInlineTagContext.class); 1250 } 1251 public JavadocInlineTagContext javadocInlineTag(int i) { 1252 return getRuleContext(JavadocInlineTagContext.class,i); 1253 } 1254 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1255 public TerminalNode LEADING_ASTERISK(int i) { 1256 return getToken(JavadocParser.LEADING_ASTERISK, i); 1257 } 1258 public HtmlTagContext(ParserRuleContext parent, int invokingState) { 1259 super(parent, invokingState); 1260 } 1261 @Override public int getRuleIndex() { return RULE_htmlTag; } 1262 @Override 1263 public void enterRule(ParseTreeListener listener) { 1264 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTag(this); 1265 } 1266 @Override 1267 public void exitRule(ParseTreeListener listener) { 1268 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTag(this); 1269 } 1270 @Override 1271 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1272 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTag(this); 1273 else return visitor.visitChildren(this); 1274 } 1275 } 1276 1277 public final HtmlTagContext htmlTag() throws RecognitionException { 1278 HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState()); 1279 enterRule(_localctx, 10, RULE_htmlTag); 1280 try { 1281 int _alt; 1282 setState(304); 1283 _errHandler.sync(this); 1284 switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) { 1285 case 1: 1286 enterOuterAlt(_localctx, 1); 1287 { 1288 setState(272); 1289 htmlElementOpen(); 1290 setState(283); 1291 _errHandler.sync(this); 1292 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1293 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1294 if ( _alt==1 ) { 1295 { 1296 setState(281); 1297 _errHandler.sync(this); 1298 switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { 1299 case 1: 1300 { 1301 setState(273); 1302 htmlElement(); 1303 } 1304 break; 1305 case 2: 1306 { 1307 { 1308 setState(274); 1309 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1310 setState(275); 1311 match(LEADING_ASTERISK); 1312 } 1313 } 1314 break; 1315 case 3: 1316 { 1317 setState(276); 1318 htmlComment(); 1319 } 1320 break; 1321 case 4: 1322 { 1323 setState(277); 1324 match(CDATA); 1325 } 1326 break; 1327 case 5: 1328 { 1329 setState(278); 1330 match(NEWLINE); 1331 } 1332 break; 1333 case 6: 1334 { 1335 setState(279); 1336 text(); 1337 } 1338 break; 1339 case 7: 1340 { 1341 setState(280); 1342 javadocInlineTag(); 1343 } 1344 break; 1345 } 1346 } 1347 } 1348 setState(285); 1349 _errHandler.sync(this); 1350 _alt = getInterpreter().adaptivePredict(_input,13,_ctx); 1351 } 1352 setState(286); 1353 htmlElementClose(); 1354 } 1355 break; 1356 case 2: 1357 enterOuterAlt(_localctx, 2); 1358 { 1359 setState(288); 1360 ((HtmlTagContext)_localctx).htmlElementOpen = htmlElementOpen(); 1361 setState(299); 1362 _errHandler.sync(this); 1363 _alt = getInterpreter().adaptivePredict(_input,15,_ctx); 1364 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1365 if ( _alt==1 ) { 1366 { 1367 setState(297); 1368 _errHandler.sync(this); 1369 switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { 1370 case 1: 1371 { 1372 setState(289); 1373 htmlElement(); 1374 } 1375 break; 1376 case 2: 1377 { 1378 { 1379 setState(290); 1380 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 1381 setState(291); 1382 match(LEADING_ASTERISK); 1383 } 1384 } 1385 break; 1386 case 3: 1387 { 1388 setState(292); 1389 htmlComment(); 1390 } 1391 break; 1392 case 4: 1393 { 1394 setState(293); 1395 match(CDATA); 1396 } 1397 break; 1398 case 5: 1399 { 1400 setState(294); 1401 match(NEWLINE); 1402 } 1403 break; 1404 case 6: 1405 { 1406 setState(295); 1407 text(); 1408 } 1409 break; 1410 case 7: 1411 { 1412 setState(296); 1413 javadocInlineTag(); 1414 } 1415 break; 1416 } 1417 } 1418 } 1419 setState(301); 1420 _errHandler.sync(this); 1421 _alt = getInterpreter().adaptivePredict(_input,15,_ctx); 1422 } 1423 notifyErrorListeners(((HtmlTagContext)_localctx).htmlElementOpen.getToken(HTML_TAG_NAME, 0).getSymbol() 1424 , "javadoc.missed.html.close", null); 1425 } 1426 break; 1427 } 1428 } 1429 catch (RecognitionException re) { 1430 _localctx.exception = re; 1431 _errHandler.reportError(this, re); 1432 _errHandler.recover(this, re); 1433 } 1434 finally { 1435 exitRule(); 1436 } 1437 return _localctx; 1438 } 1439 1440 public static class PTagOpenContext extends ParserRuleContext { 1441 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1442 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1443 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1444 public List<AttributeContext> attribute() { 1445 return getRuleContexts(AttributeContext.class); 1446 } 1447 public AttributeContext attribute(int i) { 1448 return getRuleContext(AttributeContext.class,i); 1449 } 1450 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1451 public TerminalNode NEWLINE(int i) { 1452 return getToken(JavadocParser.NEWLINE, i); 1453 } 1454 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1455 public TerminalNode LEADING_ASTERISK(int i) { 1456 return getToken(JavadocParser.LEADING_ASTERISK, i); 1457 } 1458 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1459 public TerminalNode WS(int i) { 1460 return getToken(JavadocParser.WS, i); 1461 } 1462 public PTagOpenContext(ParserRuleContext parent, int invokingState) { 1463 super(parent, invokingState); 1464 } 1465 @Override public int getRuleIndex() { return RULE_pTagOpen; } 1466 @Override 1467 public void enterRule(ParseTreeListener listener) { 1468 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagOpen(this); 1469 } 1470 @Override 1471 public void exitRule(ParseTreeListener listener) { 1472 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagOpen(this); 1473 } 1474 @Override 1475 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1476 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagOpen(this); 1477 else return visitor.visitChildren(this); 1478 } 1479 } 1480 1481 public final PTagOpenContext pTagOpen() throws RecognitionException { 1482 PTagOpenContext _localctx = new PTagOpenContext(_ctx, getState()); 1483 enterRule(_localctx, 12, RULE_pTagOpen); 1484 int _la; 1485 try { 1486 enterOuterAlt(_localctx, 1); 1487 { 1488 setState(306); 1489 match(OPEN); 1490 setState(307); 1491 match(P_HTML_TAG_NAME); 1492 setState(314); 1493 _errHandler.sync(this); 1494 _la = _input.LA(1); 1495 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 1496 { 1497 setState(312); 1498 switch (_input.LA(1)) { 1499 case HTML_TAG_NAME: 1500 { 1501 setState(308); 1502 attribute(); 1503 } 1504 break; 1505 case NEWLINE: 1506 { 1507 setState(309); 1508 match(NEWLINE); 1509 } 1510 break; 1511 case LEADING_ASTERISK: 1512 { 1513 setState(310); 1514 match(LEADING_ASTERISK); 1515 } 1516 break; 1517 case WS: 1518 { 1519 setState(311); 1520 match(WS); 1521 } 1522 break; 1523 default: 1524 throw new NoViableAltException(this); 1525 } 1526 } 1527 setState(316); 1528 _errHandler.sync(this); 1529 _la = _input.LA(1); 1530 } 1531 setState(317); 1532 match(CLOSE); 1533 } 1534 } 1535 catch (RecognitionException re) { 1536 _localctx.exception = re; 1537 _errHandler.reportError(this, re); 1538 _errHandler.recover(this, re); 1539 } 1540 finally { 1541 exitRule(); 1542 } 1543 return _localctx; 1544 } 1545 1546 public static class PTagCloseContext extends ParserRuleContext { 1547 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 1548 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 1549 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 1550 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 1551 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1552 public TerminalNode NEWLINE(int i) { 1553 return getToken(JavadocParser.NEWLINE, i); 1554 } 1555 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1556 public TerminalNode LEADING_ASTERISK(int i) { 1557 return getToken(JavadocParser.LEADING_ASTERISK, i); 1558 } 1559 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 1560 public TerminalNode WS(int i) { 1561 return getToken(JavadocParser.WS, i); 1562 } 1563 public PTagCloseContext(ParserRuleContext parent, int invokingState) { 1564 super(parent, invokingState); 1565 } 1566 @Override public int getRuleIndex() { return RULE_pTagClose; } 1567 @Override 1568 public void enterRule(ParseTreeListener listener) { 1569 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterPTagClose(this); 1570 } 1571 @Override 1572 public void exitRule(ParseTreeListener listener) { 1573 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitPTagClose(this); 1574 } 1575 @Override 1576 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1577 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagClose(this); 1578 else return visitor.visitChildren(this); 1579 } 1580 } 1581 1582 public final PTagCloseContext pTagClose() throws RecognitionException { 1583 PTagCloseContext _localctx = new PTagCloseContext(_ctx, getState()); 1584 enterRule(_localctx, 14, RULE_pTagClose); 1585 int _la; 1586 try { 1587 enterOuterAlt(_localctx, 1); 1588 { 1589 setState(319); 1590 match(OPEN); 1591 setState(320); 1592 match(SLASH); 1593 setState(321); 1594 match(P_HTML_TAG_NAME); 1595 setState(325); 1596 _errHandler.sync(this); 1597 _la = _input.LA(1); 1598 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 1599 { 1600 { 1601 setState(322); 1602 _la = _input.LA(1); 1603 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 1604 _errHandler.recoverInline(this); 1605 } else { 1606 consume(); 1607 } 1608 } 1609 } 1610 setState(327); 1611 _errHandler.sync(this); 1612 _la = _input.LA(1); 1613 } 1614 setState(328); 1615 match(CLOSE); 1616 } 1617 } 1618 catch (RecognitionException re) { 1619 _localctx.exception = re; 1620 _errHandler.reportError(this, re); 1621 _errHandler.recover(this, re); 1622 } 1623 finally { 1624 exitRule(); 1625 } 1626 return _localctx; 1627 } 1628 1629 public static class ParagraphContext extends ParserRuleContext { 1630 public PTagOpenContext pTagOpen() { 1631 return getRuleContext(PTagOpenContext.class,0); 1632 } 1633 public PTagCloseContext pTagClose() { 1634 return getRuleContext(PTagCloseContext.class,0); 1635 } 1636 public List<HtmlTagContext> htmlTag() { 1637 return getRuleContexts(HtmlTagContext.class); 1638 } 1639 public HtmlTagContext htmlTag(int i) { 1640 return getRuleContext(HtmlTagContext.class,i); 1641 } 1642 public List<SingletonTagContext> singletonTag() { 1643 return getRuleContexts(SingletonTagContext.class); 1644 } 1645 public SingletonTagContext singletonTag(int i) { 1646 return getRuleContext(SingletonTagContext.class,i); 1647 } 1648 public List<LiContext> li() { 1649 return getRuleContexts(LiContext.class); 1650 } 1651 public LiContext li(int i) { 1652 return getRuleContext(LiContext.class,i); 1653 } 1654 public List<TrContext> tr() { 1655 return getRuleContexts(TrContext.class); 1656 } 1657 public TrContext tr(int i) { 1658 return getRuleContext(TrContext.class,i); 1659 } 1660 public List<TdContext> td() { 1661 return getRuleContexts(TdContext.class); 1662 } 1663 public TdContext td(int i) { 1664 return getRuleContext(TdContext.class,i); 1665 } 1666 public List<ThContext> th() { 1667 return getRuleContexts(ThContext.class); 1668 } 1669 public ThContext th(int i) { 1670 return getRuleContext(ThContext.class,i); 1671 } 1672 public List<BodyContext> body() { 1673 return getRuleContexts(BodyContext.class); 1674 } 1675 public BodyContext body(int i) { 1676 return getRuleContext(BodyContext.class,i); 1677 } 1678 public List<ColgroupContext> colgroup() { 1679 return getRuleContexts(ColgroupContext.class); 1680 } 1681 public ColgroupContext colgroup(int i) { 1682 return getRuleContext(ColgroupContext.class,i); 1683 } 1684 public List<DdContext> dd() { 1685 return getRuleContexts(DdContext.class); 1686 } 1687 public DdContext dd(int i) { 1688 return getRuleContext(DdContext.class,i); 1689 } 1690 public List<DtContext> dt() { 1691 return getRuleContexts(DtContext.class); 1692 } 1693 public DtContext dt(int i) { 1694 return getRuleContext(DtContext.class,i); 1695 } 1696 public List<HeadContext> head() { 1697 return getRuleContexts(HeadContext.class); 1698 } 1699 public HeadContext head(int i) { 1700 return getRuleContext(HeadContext.class,i); 1701 } 1702 public List<HtmlContext> html() { 1703 return getRuleContexts(HtmlContext.class); 1704 } 1705 public HtmlContext html(int i) { 1706 return getRuleContext(HtmlContext.class,i); 1707 } 1708 public List<OptionContext> option() { 1709 return getRuleContexts(OptionContext.class); 1710 } 1711 public OptionContext option(int i) { 1712 return getRuleContext(OptionContext.class,i); 1713 } 1714 public List<TbodyContext> tbody() { 1715 return getRuleContexts(TbodyContext.class); 1716 } 1717 public TbodyContext tbody(int i) { 1718 return getRuleContext(TbodyContext.class,i); 1719 } 1720 public List<TheadContext> thead() { 1721 return getRuleContexts(TheadContext.class); 1722 } 1723 public TheadContext thead(int i) { 1724 return getRuleContext(TheadContext.class,i); 1725 } 1726 public List<TfootContext> tfoot() { 1727 return getRuleContexts(TfootContext.class); 1728 } 1729 public TfootContext tfoot(int i) { 1730 return getRuleContext(TfootContext.class,i); 1731 } 1732 public List<LiTagOpenContext> liTagOpen() { 1733 return getRuleContexts(LiTagOpenContext.class); 1734 } 1735 public LiTagOpenContext liTagOpen(int i) { 1736 return getRuleContext(LiTagOpenContext.class,i); 1737 } 1738 public List<TrTagOpenContext> trTagOpen() { 1739 return getRuleContexts(TrTagOpenContext.class); 1740 } 1741 public TrTagOpenContext trTagOpen(int i) { 1742 return getRuleContext(TrTagOpenContext.class,i); 1743 } 1744 public List<TdTagOpenContext> tdTagOpen() { 1745 return getRuleContexts(TdTagOpenContext.class); 1746 } 1747 public TdTagOpenContext tdTagOpen(int i) { 1748 return getRuleContext(TdTagOpenContext.class,i); 1749 } 1750 public List<ThTagOpenContext> thTagOpen() { 1751 return getRuleContexts(ThTagOpenContext.class); 1752 } 1753 public ThTagOpenContext thTagOpen(int i) { 1754 return getRuleContext(ThTagOpenContext.class,i); 1755 } 1756 public List<BodyTagOpenContext> bodyTagOpen() { 1757 return getRuleContexts(BodyTagOpenContext.class); 1758 } 1759 public BodyTagOpenContext bodyTagOpen(int i) { 1760 return getRuleContext(BodyTagOpenContext.class,i); 1761 } 1762 public List<ColgroupTagOpenContext> colgroupTagOpen() { 1763 return getRuleContexts(ColgroupTagOpenContext.class); 1764 } 1765 public ColgroupTagOpenContext colgroupTagOpen(int i) { 1766 return getRuleContext(ColgroupTagOpenContext.class,i); 1767 } 1768 public List<DdTagOpenContext> ddTagOpen() { 1769 return getRuleContexts(DdTagOpenContext.class); 1770 } 1771 public DdTagOpenContext ddTagOpen(int i) { 1772 return getRuleContext(DdTagOpenContext.class,i); 1773 } 1774 public List<DtTagOpenContext> dtTagOpen() { 1775 return getRuleContexts(DtTagOpenContext.class); 1776 } 1777 public DtTagOpenContext dtTagOpen(int i) { 1778 return getRuleContext(DtTagOpenContext.class,i); 1779 } 1780 public List<HeadTagOpenContext> headTagOpen() { 1781 return getRuleContexts(HeadTagOpenContext.class); 1782 } 1783 public HeadTagOpenContext headTagOpen(int i) { 1784 return getRuleContext(HeadTagOpenContext.class,i); 1785 } 1786 public List<HtmlTagOpenContext> htmlTagOpen() { 1787 return getRuleContexts(HtmlTagOpenContext.class); 1788 } 1789 public HtmlTagOpenContext htmlTagOpen(int i) { 1790 return getRuleContext(HtmlTagOpenContext.class,i); 1791 } 1792 public List<OptionTagOpenContext> optionTagOpen() { 1793 return getRuleContexts(OptionTagOpenContext.class); 1794 } 1795 public OptionTagOpenContext optionTagOpen(int i) { 1796 return getRuleContext(OptionTagOpenContext.class,i); 1797 } 1798 public List<TbodyTagOpenContext> tbodyTagOpen() { 1799 return getRuleContexts(TbodyTagOpenContext.class); 1800 } 1801 public TbodyTagOpenContext tbodyTagOpen(int i) { 1802 return getRuleContext(TbodyTagOpenContext.class,i); 1803 } 1804 public List<TheadTagOpenContext> theadTagOpen() { 1805 return getRuleContexts(TheadTagOpenContext.class); 1806 } 1807 public TheadTagOpenContext theadTagOpen(int i) { 1808 return getRuleContext(TheadTagOpenContext.class,i); 1809 } 1810 public List<TfootTagOpenContext> tfootTagOpen() { 1811 return getRuleContexts(TfootTagOpenContext.class); 1812 } 1813 public TfootTagOpenContext tfootTagOpen(int i) { 1814 return getRuleContext(TfootTagOpenContext.class,i); 1815 } 1816 public List<HtmlCommentContext> htmlComment() { 1817 return getRuleContexts(HtmlCommentContext.class); 1818 } 1819 public HtmlCommentContext htmlComment(int i) { 1820 return getRuleContext(HtmlCommentContext.class,i); 1821 } 1822 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 1823 public TerminalNode CDATA(int i) { 1824 return getToken(JavadocParser.CDATA, i); 1825 } 1826 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 1827 public TerminalNode NEWLINE(int i) { 1828 return getToken(JavadocParser.NEWLINE, i); 1829 } 1830 public List<TextContext> text() { 1831 return getRuleContexts(TextContext.class); 1832 } 1833 public TextContext text(int i) { 1834 return getRuleContext(TextContext.class,i); 1835 } 1836 public List<JavadocInlineTagContext> javadocInlineTag() { 1837 return getRuleContexts(JavadocInlineTagContext.class); 1838 } 1839 public JavadocInlineTagContext javadocInlineTag(int i) { 1840 return getRuleContext(JavadocInlineTagContext.class,i); 1841 } 1842 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 1843 public TerminalNode LEADING_ASTERISK(int i) { 1844 return getToken(JavadocParser.LEADING_ASTERISK, i); 1845 } 1846 public ParagraphContext(ParserRuleContext parent, int invokingState) { 1847 super(parent, invokingState); 1848 } 1849 @Override public int getRuleIndex() { return RULE_paragraph; } 1850 @Override 1851 public void enterRule(ParseTreeListener listener) { 1852 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParagraph(this); 1853 } 1854 @Override 1855 public void exitRule(ParseTreeListener listener) { 1856 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParagraph(this); 1857 } 1858 @Override 1859 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 1860 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParagraph(this); 1861 else return visitor.visitChildren(this); 1862 } 1863 } 1864 1865 public final ParagraphContext paragraph() throws RecognitionException { 1866 ParagraphContext _localctx = new ParagraphContext(_ctx, getState()); 1867 enterRule(_localctx, 16, RULE_paragraph); 1868 try { 1869 int _alt; 1870 enterOuterAlt(_localctx, 1); 1871 { 1872 setState(330); 1873 pTagOpen(); 1874 setState(370); 1875 _errHandler.sync(this); 1876 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 1877 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 1878 if ( _alt==1 ) { 1879 { 1880 setState(368); 1881 _errHandler.sync(this); 1882 switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) { 1883 case 1: 1884 { 1885 setState(331); 1886 htmlTag(); 1887 } 1888 break; 1889 case 2: 1890 { 1891 setState(332); 1892 singletonTag(); 1893 } 1894 break; 1895 case 3: 1896 { 1897 setState(333); 1898 li(); 1899 } 1900 break; 1901 case 4: 1902 { 1903 setState(334); 1904 tr(); 1905 } 1906 break; 1907 case 5: 1908 { 1909 setState(335); 1910 td(); 1911 } 1912 break; 1913 case 6: 1914 { 1915 setState(336); 1916 th(); 1917 } 1918 break; 1919 case 7: 1920 { 1921 setState(337); 1922 body(); 1923 } 1924 break; 1925 case 8: 1926 { 1927 setState(338); 1928 colgroup(); 1929 } 1930 break; 1931 case 9: 1932 { 1933 setState(339); 1934 dd(); 1935 } 1936 break; 1937 case 10: 1938 { 1939 setState(340); 1940 dt(); 1941 } 1942 break; 1943 case 11: 1944 { 1945 setState(341); 1946 head(); 1947 } 1948 break; 1949 case 12: 1950 { 1951 setState(342); 1952 html(); 1953 } 1954 break; 1955 case 13: 1956 { 1957 setState(343); 1958 option(); 1959 } 1960 break; 1961 case 14: 1962 { 1963 setState(344); 1964 tbody(); 1965 } 1966 break; 1967 case 15: 1968 { 1969 setState(345); 1970 thead(); 1971 } 1972 break; 1973 case 16: 1974 { 1975 setState(346); 1976 tfoot(); 1977 } 1978 break; 1979 case 17: 1980 { 1981 setState(347); 1982 liTagOpen(); 1983 } 1984 break; 1985 case 18: 1986 { 1987 setState(348); 1988 trTagOpen(); 1989 } 1990 break; 1991 case 19: 1992 { 1993 setState(349); 1994 tdTagOpen(); 1995 } 1996 break; 1997 case 20: 1998 { 1999 setState(350); 2000 thTagOpen(); 2001 } 2002 break; 2003 case 21: 2004 { 2005 setState(351); 2006 bodyTagOpen(); 2007 } 2008 break; 2009 case 22: 2010 { 2011 setState(352); 2012 colgroupTagOpen(); 2013 } 2014 break; 2015 case 23: 2016 { 2017 setState(353); 2018 ddTagOpen(); 2019 } 2020 break; 2021 case 24: 2022 { 2023 setState(354); 2024 dtTagOpen(); 2025 } 2026 break; 2027 case 25: 2028 { 2029 setState(355); 2030 headTagOpen(); 2031 } 2032 break; 2033 case 26: 2034 { 2035 setState(356); 2036 htmlTagOpen(); 2037 } 2038 break; 2039 case 27: 2040 { 2041 setState(357); 2042 optionTagOpen(); 2043 } 2044 break; 2045 case 28: 2046 { 2047 setState(358); 2048 tbodyTagOpen(); 2049 } 2050 break; 2051 case 29: 2052 { 2053 setState(359); 2054 theadTagOpen(); 2055 } 2056 break; 2057 case 30: 2058 { 2059 setState(360); 2060 tfootTagOpen(); 2061 } 2062 break; 2063 case 31: 2064 { 2065 { 2066 setState(361); 2067 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2068 setState(362); 2069 match(LEADING_ASTERISK); 2070 } 2071 } 2072 break; 2073 case 32: 2074 { 2075 setState(363); 2076 htmlComment(); 2077 } 2078 break; 2079 case 33: 2080 { 2081 setState(364); 2082 match(CDATA); 2083 } 2084 break; 2085 case 34: 2086 { 2087 setState(365); 2088 match(NEWLINE); 2089 } 2090 break; 2091 case 35: 2092 { 2093 setState(366); 2094 text(); 2095 } 2096 break; 2097 case 36: 2098 { 2099 setState(367); 2100 javadocInlineTag(); 2101 } 2102 break; 2103 } 2104 } 2105 } 2106 setState(372); 2107 _errHandler.sync(this); 2108 _alt = getInterpreter().adaptivePredict(_input,21,_ctx); 2109 } 2110 setState(373); 2111 pTagClose(); 2112 } 2113 } 2114 catch (RecognitionException re) { 2115 _localctx.exception = re; 2116 _errHandler.reportError(this, re); 2117 _errHandler.recover(this, re); 2118 } 2119 finally { 2120 exitRule(); 2121 } 2122 return _localctx; 2123 } 2124 2125 public static class LiTagOpenContext extends ParserRuleContext { 2126 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2127 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2128 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2129 public List<AttributeContext> attribute() { 2130 return getRuleContexts(AttributeContext.class); 2131 } 2132 public AttributeContext attribute(int i) { 2133 return getRuleContext(AttributeContext.class,i); 2134 } 2135 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2136 public TerminalNode NEWLINE(int i) { 2137 return getToken(JavadocParser.NEWLINE, i); 2138 } 2139 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2140 public TerminalNode LEADING_ASTERISK(int i) { 2141 return getToken(JavadocParser.LEADING_ASTERISK, i); 2142 } 2143 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2144 public TerminalNode WS(int i) { 2145 return getToken(JavadocParser.WS, i); 2146 } 2147 public LiTagOpenContext(ParserRuleContext parent, int invokingState) { 2148 super(parent, invokingState); 2149 } 2150 @Override public int getRuleIndex() { return RULE_liTagOpen; } 2151 @Override 2152 public void enterRule(ParseTreeListener listener) { 2153 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagOpen(this); 2154 } 2155 @Override 2156 public void exitRule(ParseTreeListener listener) { 2157 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagOpen(this); 2158 } 2159 @Override 2160 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2161 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagOpen(this); 2162 else return visitor.visitChildren(this); 2163 } 2164 } 2165 2166 public final LiTagOpenContext liTagOpen() throws RecognitionException { 2167 LiTagOpenContext _localctx = new LiTagOpenContext(_ctx, getState()); 2168 enterRule(_localctx, 18, RULE_liTagOpen); 2169 int _la; 2170 try { 2171 enterOuterAlt(_localctx, 1); 2172 { 2173 setState(375); 2174 match(OPEN); 2175 setState(376); 2176 match(LI_HTML_TAG_NAME); 2177 setState(383); 2178 _errHandler.sync(this); 2179 _la = _input.LA(1); 2180 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2181 { 2182 setState(381); 2183 switch (_input.LA(1)) { 2184 case HTML_TAG_NAME: 2185 { 2186 setState(377); 2187 attribute(); 2188 } 2189 break; 2190 case NEWLINE: 2191 { 2192 setState(378); 2193 match(NEWLINE); 2194 } 2195 break; 2196 case LEADING_ASTERISK: 2197 { 2198 setState(379); 2199 match(LEADING_ASTERISK); 2200 } 2201 break; 2202 case WS: 2203 { 2204 setState(380); 2205 match(WS); 2206 } 2207 break; 2208 default: 2209 throw new NoViableAltException(this); 2210 } 2211 } 2212 setState(385); 2213 _errHandler.sync(this); 2214 _la = _input.LA(1); 2215 } 2216 setState(386); 2217 match(CLOSE); 2218 } 2219 } 2220 catch (RecognitionException re) { 2221 _localctx.exception = re; 2222 _errHandler.reportError(this, re); 2223 _errHandler.recover(this, re); 2224 } 2225 finally { 2226 exitRule(); 2227 } 2228 return _localctx; 2229 } 2230 2231 public static class LiTagCloseContext extends ParserRuleContext { 2232 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2233 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2234 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 2235 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2236 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2237 public TerminalNode NEWLINE(int i) { 2238 return getToken(JavadocParser.NEWLINE, i); 2239 } 2240 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2241 public TerminalNode LEADING_ASTERISK(int i) { 2242 return getToken(JavadocParser.LEADING_ASTERISK, i); 2243 } 2244 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2245 public TerminalNode WS(int i) { 2246 return getToken(JavadocParser.WS, i); 2247 } 2248 public LiTagCloseContext(ParserRuleContext parent, int invokingState) { 2249 super(parent, invokingState); 2250 } 2251 @Override public int getRuleIndex() { return RULE_liTagClose; } 2252 @Override 2253 public void enterRule(ParseTreeListener listener) { 2254 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLiTagClose(this); 2255 } 2256 @Override 2257 public void exitRule(ParseTreeListener listener) { 2258 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLiTagClose(this); 2259 } 2260 @Override 2261 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2262 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagClose(this); 2263 else return visitor.visitChildren(this); 2264 } 2265 } 2266 2267 public final LiTagCloseContext liTagClose() throws RecognitionException { 2268 LiTagCloseContext _localctx = new LiTagCloseContext(_ctx, getState()); 2269 enterRule(_localctx, 20, RULE_liTagClose); 2270 int _la; 2271 try { 2272 enterOuterAlt(_localctx, 1); 2273 { 2274 setState(388); 2275 match(OPEN); 2276 setState(389); 2277 match(SLASH); 2278 setState(390); 2279 match(LI_HTML_TAG_NAME); 2280 setState(394); 2281 _errHandler.sync(this); 2282 _la = _input.LA(1); 2283 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2284 { 2285 { 2286 setState(391); 2287 _la = _input.LA(1); 2288 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2289 _errHandler.recoverInline(this); 2290 } else { 2291 consume(); 2292 } 2293 } 2294 } 2295 setState(396); 2296 _errHandler.sync(this); 2297 _la = _input.LA(1); 2298 } 2299 setState(397); 2300 match(CLOSE); 2301 } 2302 } 2303 catch (RecognitionException re) { 2304 _localctx.exception = re; 2305 _errHandler.reportError(this, re); 2306 _errHandler.recover(this, re); 2307 } 2308 finally { 2309 exitRule(); 2310 } 2311 return _localctx; 2312 } 2313 2314 public static class LiContext extends ParserRuleContext { 2315 public LiTagOpenContext liTagOpen() { 2316 return getRuleContext(LiTagOpenContext.class,0); 2317 } 2318 public LiTagCloseContext liTagClose() { 2319 return getRuleContext(LiTagCloseContext.class,0); 2320 } 2321 public List<HtmlTagContext> htmlTag() { 2322 return getRuleContexts(HtmlTagContext.class); 2323 } 2324 public HtmlTagContext htmlTag(int i) { 2325 return getRuleContext(HtmlTagContext.class,i); 2326 } 2327 public List<SingletonTagContext> singletonTag() { 2328 return getRuleContexts(SingletonTagContext.class); 2329 } 2330 public SingletonTagContext singletonTag(int i) { 2331 return getRuleContext(SingletonTagContext.class,i); 2332 } 2333 public List<ParagraphContext> paragraph() { 2334 return getRuleContexts(ParagraphContext.class); 2335 } 2336 public ParagraphContext paragraph(int i) { 2337 return getRuleContext(ParagraphContext.class,i); 2338 } 2339 public List<TrContext> tr() { 2340 return getRuleContexts(TrContext.class); 2341 } 2342 public TrContext tr(int i) { 2343 return getRuleContext(TrContext.class,i); 2344 } 2345 public List<TdContext> td() { 2346 return getRuleContexts(TdContext.class); 2347 } 2348 public TdContext td(int i) { 2349 return getRuleContext(TdContext.class,i); 2350 } 2351 public List<ThContext> th() { 2352 return getRuleContexts(ThContext.class); 2353 } 2354 public ThContext th(int i) { 2355 return getRuleContext(ThContext.class,i); 2356 } 2357 public List<BodyContext> body() { 2358 return getRuleContexts(BodyContext.class); 2359 } 2360 public BodyContext body(int i) { 2361 return getRuleContext(BodyContext.class,i); 2362 } 2363 public List<ColgroupContext> colgroup() { 2364 return getRuleContexts(ColgroupContext.class); 2365 } 2366 public ColgroupContext colgroup(int i) { 2367 return getRuleContext(ColgroupContext.class,i); 2368 } 2369 public List<DdContext> dd() { 2370 return getRuleContexts(DdContext.class); 2371 } 2372 public DdContext dd(int i) { 2373 return getRuleContext(DdContext.class,i); 2374 } 2375 public List<DtContext> dt() { 2376 return getRuleContexts(DtContext.class); 2377 } 2378 public DtContext dt(int i) { 2379 return getRuleContext(DtContext.class,i); 2380 } 2381 public List<HeadContext> head() { 2382 return getRuleContexts(HeadContext.class); 2383 } 2384 public HeadContext head(int i) { 2385 return getRuleContext(HeadContext.class,i); 2386 } 2387 public List<HtmlContext> html() { 2388 return getRuleContexts(HtmlContext.class); 2389 } 2390 public HtmlContext html(int i) { 2391 return getRuleContext(HtmlContext.class,i); 2392 } 2393 public List<OptionContext> option() { 2394 return getRuleContexts(OptionContext.class); 2395 } 2396 public OptionContext option(int i) { 2397 return getRuleContext(OptionContext.class,i); 2398 } 2399 public List<TbodyContext> tbody() { 2400 return getRuleContexts(TbodyContext.class); 2401 } 2402 public TbodyContext tbody(int i) { 2403 return getRuleContext(TbodyContext.class,i); 2404 } 2405 public List<TheadContext> thead() { 2406 return getRuleContexts(TheadContext.class); 2407 } 2408 public TheadContext thead(int i) { 2409 return getRuleContext(TheadContext.class,i); 2410 } 2411 public List<TfootContext> tfoot() { 2412 return getRuleContexts(TfootContext.class); 2413 } 2414 public TfootContext tfoot(int i) { 2415 return getRuleContext(TfootContext.class,i); 2416 } 2417 public List<PTagOpenContext> pTagOpen() { 2418 return getRuleContexts(PTagOpenContext.class); 2419 } 2420 public PTagOpenContext pTagOpen(int i) { 2421 return getRuleContext(PTagOpenContext.class,i); 2422 } 2423 public List<TrTagOpenContext> trTagOpen() { 2424 return getRuleContexts(TrTagOpenContext.class); 2425 } 2426 public TrTagOpenContext trTagOpen(int i) { 2427 return getRuleContext(TrTagOpenContext.class,i); 2428 } 2429 public List<TdTagOpenContext> tdTagOpen() { 2430 return getRuleContexts(TdTagOpenContext.class); 2431 } 2432 public TdTagOpenContext tdTagOpen(int i) { 2433 return getRuleContext(TdTagOpenContext.class,i); 2434 } 2435 public List<ThTagOpenContext> thTagOpen() { 2436 return getRuleContexts(ThTagOpenContext.class); 2437 } 2438 public ThTagOpenContext thTagOpen(int i) { 2439 return getRuleContext(ThTagOpenContext.class,i); 2440 } 2441 public List<BodyTagOpenContext> bodyTagOpen() { 2442 return getRuleContexts(BodyTagOpenContext.class); 2443 } 2444 public BodyTagOpenContext bodyTagOpen(int i) { 2445 return getRuleContext(BodyTagOpenContext.class,i); 2446 } 2447 public List<ColgroupTagOpenContext> colgroupTagOpen() { 2448 return getRuleContexts(ColgroupTagOpenContext.class); 2449 } 2450 public ColgroupTagOpenContext colgroupTagOpen(int i) { 2451 return getRuleContext(ColgroupTagOpenContext.class,i); 2452 } 2453 public List<DdTagOpenContext> ddTagOpen() { 2454 return getRuleContexts(DdTagOpenContext.class); 2455 } 2456 public DdTagOpenContext ddTagOpen(int i) { 2457 return getRuleContext(DdTagOpenContext.class,i); 2458 } 2459 public List<DtTagOpenContext> dtTagOpen() { 2460 return getRuleContexts(DtTagOpenContext.class); 2461 } 2462 public DtTagOpenContext dtTagOpen(int i) { 2463 return getRuleContext(DtTagOpenContext.class,i); 2464 } 2465 public List<HeadTagOpenContext> headTagOpen() { 2466 return getRuleContexts(HeadTagOpenContext.class); 2467 } 2468 public HeadTagOpenContext headTagOpen(int i) { 2469 return getRuleContext(HeadTagOpenContext.class,i); 2470 } 2471 public List<HtmlTagOpenContext> htmlTagOpen() { 2472 return getRuleContexts(HtmlTagOpenContext.class); 2473 } 2474 public HtmlTagOpenContext htmlTagOpen(int i) { 2475 return getRuleContext(HtmlTagOpenContext.class,i); 2476 } 2477 public List<OptionTagOpenContext> optionTagOpen() { 2478 return getRuleContexts(OptionTagOpenContext.class); 2479 } 2480 public OptionTagOpenContext optionTagOpen(int i) { 2481 return getRuleContext(OptionTagOpenContext.class,i); 2482 } 2483 public List<TbodyTagOpenContext> tbodyTagOpen() { 2484 return getRuleContexts(TbodyTagOpenContext.class); 2485 } 2486 public TbodyTagOpenContext tbodyTagOpen(int i) { 2487 return getRuleContext(TbodyTagOpenContext.class,i); 2488 } 2489 public List<TheadTagOpenContext> theadTagOpen() { 2490 return getRuleContexts(TheadTagOpenContext.class); 2491 } 2492 public TheadTagOpenContext theadTagOpen(int i) { 2493 return getRuleContext(TheadTagOpenContext.class,i); 2494 } 2495 public List<TfootTagOpenContext> tfootTagOpen() { 2496 return getRuleContexts(TfootTagOpenContext.class); 2497 } 2498 public TfootTagOpenContext tfootTagOpen(int i) { 2499 return getRuleContext(TfootTagOpenContext.class,i); 2500 } 2501 public List<HtmlCommentContext> htmlComment() { 2502 return getRuleContexts(HtmlCommentContext.class); 2503 } 2504 public HtmlCommentContext htmlComment(int i) { 2505 return getRuleContext(HtmlCommentContext.class,i); 2506 } 2507 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 2508 public TerminalNode CDATA(int i) { 2509 return getToken(JavadocParser.CDATA, i); 2510 } 2511 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2512 public TerminalNode NEWLINE(int i) { 2513 return getToken(JavadocParser.NEWLINE, i); 2514 } 2515 public List<TextContext> text() { 2516 return getRuleContexts(TextContext.class); 2517 } 2518 public TextContext text(int i) { 2519 return getRuleContext(TextContext.class,i); 2520 } 2521 public List<JavadocInlineTagContext> javadocInlineTag() { 2522 return getRuleContexts(JavadocInlineTagContext.class); 2523 } 2524 public JavadocInlineTagContext javadocInlineTag(int i) { 2525 return getRuleContext(JavadocInlineTagContext.class,i); 2526 } 2527 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2528 public TerminalNode LEADING_ASTERISK(int i) { 2529 return getToken(JavadocParser.LEADING_ASTERISK, i); 2530 } 2531 public LiContext(ParserRuleContext parent, int invokingState) { 2532 super(parent, invokingState); 2533 } 2534 @Override public int getRuleIndex() { return RULE_li; } 2535 @Override 2536 public void enterRule(ParseTreeListener listener) { 2537 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLi(this); 2538 } 2539 @Override 2540 public void exitRule(ParseTreeListener listener) { 2541 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLi(this); 2542 } 2543 @Override 2544 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2545 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLi(this); 2546 else return visitor.visitChildren(this); 2547 } 2548 } 2549 2550 public final LiContext li() throws RecognitionException { 2551 LiContext _localctx = new LiContext(_ctx, getState()); 2552 enterRule(_localctx, 22, RULE_li); 2553 try { 2554 int _alt; 2555 enterOuterAlt(_localctx, 1); 2556 { 2557 setState(399); 2558 liTagOpen(); 2559 setState(439); 2560 _errHandler.sync(this); 2561 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 2562 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 2563 if ( _alt==1 ) { 2564 { 2565 setState(437); 2566 _errHandler.sync(this); 2567 switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) { 2568 case 1: 2569 { 2570 setState(400); 2571 htmlTag(); 2572 } 2573 break; 2574 case 2: 2575 { 2576 setState(401); 2577 singletonTag(); 2578 } 2579 break; 2580 case 3: 2581 { 2582 setState(402); 2583 paragraph(); 2584 } 2585 break; 2586 case 4: 2587 { 2588 setState(403); 2589 tr(); 2590 } 2591 break; 2592 case 5: 2593 { 2594 setState(404); 2595 td(); 2596 } 2597 break; 2598 case 6: 2599 { 2600 setState(405); 2601 th(); 2602 } 2603 break; 2604 case 7: 2605 { 2606 setState(406); 2607 body(); 2608 } 2609 break; 2610 case 8: 2611 { 2612 setState(407); 2613 colgroup(); 2614 } 2615 break; 2616 case 9: 2617 { 2618 setState(408); 2619 dd(); 2620 } 2621 break; 2622 case 10: 2623 { 2624 setState(409); 2625 dt(); 2626 } 2627 break; 2628 case 11: 2629 { 2630 setState(410); 2631 head(); 2632 } 2633 break; 2634 case 12: 2635 { 2636 setState(411); 2637 html(); 2638 } 2639 break; 2640 case 13: 2641 { 2642 setState(412); 2643 option(); 2644 } 2645 break; 2646 case 14: 2647 { 2648 setState(413); 2649 tbody(); 2650 } 2651 break; 2652 case 15: 2653 { 2654 setState(414); 2655 thead(); 2656 } 2657 break; 2658 case 16: 2659 { 2660 setState(415); 2661 tfoot(); 2662 } 2663 break; 2664 case 17: 2665 { 2666 setState(416); 2667 pTagOpen(); 2668 } 2669 break; 2670 case 18: 2671 { 2672 setState(417); 2673 trTagOpen(); 2674 } 2675 break; 2676 case 19: 2677 { 2678 setState(418); 2679 tdTagOpen(); 2680 } 2681 break; 2682 case 20: 2683 { 2684 setState(419); 2685 thTagOpen(); 2686 } 2687 break; 2688 case 21: 2689 { 2690 setState(420); 2691 bodyTagOpen(); 2692 } 2693 break; 2694 case 22: 2695 { 2696 setState(421); 2697 colgroupTagOpen(); 2698 } 2699 break; 2700 case 23: 2701 { 2702 setState(422); 2703 ddTagOpen(); 2704 } 2705 break; 2706 case 24: 2707 { 2708 setState(423); 2709 dtTagOpen(); 2710 } 2711 break; 2712 case 25: 2713 { 2714 setState(424); 2715 headTagOpen(); 2716 } 2717 break; 2718 case 26: 2719 { 2720 setState(425); 2721 htmlTagOpen(); 2722 } 2723 break; 2724 case 27: 2725 { 2726 setState(426); 2727 optionTagOpen(); 2728 } 2729 break; 2730 case 28: 2731 { 2732 setState(427); 2733 tbodyTagOpen(); 2734 } 2735 break; 2736 case 29: 2737 { 2738 setState(428); 2739 theadTagOpen(); 2740 } 2741 break; 2742 case 30: 2743 { 2744 setState(429); 2745 tfootTagOpen(); 2746 } 2747 break; 2748 case 31: 2749 { 2750 { 2751 setState(430); 2752 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 2753 setState(431); 2754 match(LEADING_ASTERISK); 2755 } 2756 } 2757 break; 2758 case 32: 2759 { 2760 setState(432); 2761 htmlComment(); 2762 } 2763 break; 2764 case 33: 2765 { 2766 setState(433); 2767 match(CDATA); 2768 } 2769 break; 2770 case 34: 2771 { 2772 setState(434); 2773 match(NEWLINE); 2774 } 2775 break; 2776 case 35: 2777 { 2778 setState(435); 2779 text(); 2780 } 2781 break; 2782 case 36: 2783 { 2784 setState(436); 2785 javadocInlineTag(); 2786 } 2787 break; 2788 } 2789 } 2790 } 2791 setState(441); 2792 _errHandler.sync(this); 2793 _alt = getInterpreter().adaptivePredict(_input,26,_ctx); 2794 } 2795 setState(442); 2796 liTagClose(); 2797 } 2798 } 2799 catch (RecognitionException re) { 2800 _localctx.exception = re; 2801 _errHandler.reportError(this, re); 2802 _errHandler.recover(this, re); 2803 } 2804 finally { 2805 exitRule(); 2806 } 2807 return _localctx; 2808 } 2809 2810 public static class TrTagOpenContext extends ParserRuleContext { 2811 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2812 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2813 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2814 public List<AttributeContext> attribute() { 2815 return getRuleContexts(AttributeContext.class); 2816 } 2817 public AttributeContext attribute(int i) { 2818 return getRuleContext(AttributeContext.class,i); 2819 } 2820 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2821 public TerminalNode NEWLINE(int i) { 2822 return getToken(JavadocParser.NEWLINE, i); 2823 } 2824 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2825 public TerminalNode LEADING_ASTERISK(int i) { 2826 return getToken(JavadocParser.LEADING_ASTERISK, i); 2827 } 2828 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2829 public TerminalNode WS(int i) { 2830 return getToken(JavadocParser.WS, i); 2831 } 2832 public TrTagOpenContext(ParserRuleContext parent, int invokingState) { 2833 super(parent, invokingState); 2834 } 2835 @Override public int getRuleIndex() { return RULE_trTagOpen; } 2836 @Override 2837 public void enterRule(ParseTreeListener listener) { 2838 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagOpen(this); 2839 } 2840 @Override 2841 public void exitRule(ParseTreeListener listener) { 2842 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagOpen(this); 2843 } 2844 @Override 2845 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2846 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagOpen(this); 2847 else return visitor.visitChildren(this); 2848 } 2849 } 2850 2851 public final TrTagOpenContext trTagOpen() throws RecognitionException { 2852 TrTagOpenContext _localctx = new TrTagOpenContext(_ctx, getState()); 2853 enterRule(_localctx, 24, RULE_trTagOpen); 2854 int _la; 2855 try { 2856 enterOuterAlt(_localctx, 1); 2857 { 2858 setState(444); 2859 match(OPEN); 2860 setState(445); 2861 match(TR_HTML_TAG_NAME); 2862 setState(452); 2863 _errHandler.sync(this); 2864 _la = _input.LA(1); 2865 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 2866 { 2867 setState(450); 2868 switch (_input.LA(1)) { 2869 case HTML_TAG_NAME: 2870 { 2871 setState(446); 2872 attribute(); 2873 } 2874 break; 2875 case NEWLINE: 2876 { 2877 setState(447); 2878 match(NEWLINE); 2879 } 2880 break; 2881 case LEADING_ASTERISK: 2882 { 2883 setState(448); 2884 match(LEADING_ASTERISK); 2885 } 2886 break; 2887 case WS: 2888 { 2889 setState(449); 2890 match(WS); 2891 } 2892 break; 2893 default: 2894 throw new NoViableAltException(this); 2895 } 2896 } 2897 setState(454); 2898 _errHandler.sync(this); 2899 _la = _input.LA(1); 2900 } 2901 setState(455); 2902 match(CLOSE); 2903 } 2904 } 2905 catch (RecognitionException re) { 2906 _localctx.exception = re; 2907 _errHandler.reportError(this, re); 2908 _errHandler.recover(this, re); 2909 } 2910 finally { 2911 exitRule(); 2912 } 2913 return _localctx; 2914 } 2915 2916 public static class TrTagCloseContext extends ParserRuleContext { 2917 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 2918 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 2919 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 2920 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 2921 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 2922 public TerminalNode NEWLINE(int i) { 2923 return getToken(JavadocParser.NEWLINE, i); 2924 } 2925 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 2926 public TerminalNode LEADING_ASTERISK(int i) { 2927 return getToken(JavadocParser.LEADING_ASTERISK, i); 2928 } 2929 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 2930 public TerminalNode WS(int i) { 2931 return getToken(JavadocParser.WS, i); 2932 } 2933 public TrTagCloseContext(ParserRuleContext parent, int invokingState) { 2934 super(parent, invokingState); 2935 } 2936 @Override public int getRuleIndex() { return RULE_trTagClose; } 2937 @Override 2938 public void enterRule(ParseTreeListener listener) { 2939 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTrTagClose(this); 2940 } 2941 @Override 2942 public void exitRule(ParseTreeListener listener) { 2943 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTrTagClose(this); 2944 } 2945 @Override 2946 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 2947 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagClose(this); 2948 else return visitor.visitChildren(this); 2949 } 2950 } 2951 2952 public final TrTagCloseContext trTagClose() throws RecognitionException { 2953 TrTagCloseContext _localctx = new TrTagCloseContext(_ctx, getState()); 2954 enterRule(_localctx, 26, RULE_trTagClose); 2955 int _la; 2956 try { 2957 enterOuterAlt(_localctx, 1); 2958 { 2959 setState(457); 2960 match(OPEN); 2961 setState(458); 2962 match(SLASH); 2963 setState(459); 2964 match(TR_HTML_TAG_NAME); 2965 setState(463); 2966 _errHandler.sync(this); 2967 _la = _input.LA(1); 2968 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 2969 { 2970 { 2971 setState(460); 2972 _la = _input.LA(1); 2973 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 2974 _errHandler.recoverInline(this); 2975 } else { 2976 consume(); 2977 } 2978 } 2979 } 2980 setState(465); 2981 _errHandler.sync(this); 2982 _la = _input.LA(1); 2983 } 2984 setState(466); 2985 match(CLOSE); 2986 } 2987 } 2988 catch (RecognitionException re) { 2989 _localctx.exception = re; 2990 _errHandler.reportError(this, re); 2991 _errHandler.recover(this, re); 2992 } 2993 finally { 2994 exitRule(); 2995 } 2996 return _localctx; 2997 } 2998 2999 public static class TrContext extends ParserRuleContext { 3000 public TrTagOpenContext trTagOpen() { 3001 return getRuleContext(TrTagOpenContext.class,0); 3002 } 3003 public TrTagCloseContext trTagClose() { 3004 return getRuleContext(TrTagCloseContext.class,0); 3005 } 3006 public List<HtmlTagContext> htmlTag() { 3007 return getRuleContexts(HtmlTagContext.class); 3008 } 3009 public HtmlTagContext htmlTag(int i) { 3010 return getRuleContext(HtmlTagContext.class,i); 3011 } 3012 public List<SingletonTagContext> singletonTag() { 3013 return getRuleContexts(SingletonTagContext.class); 3014 } 3015 public SingletonTagContext singletonTag(int i) { 3016 return getRuleContext(SingletonTagContext.class,i); 3017 } 3018 public List<ParagraphContext> paragraph() { 3019 return getRuleContexts(ParagraphContext.class); 3020 } 3021 public ParagraphContext paragraph(int i) { 3022 return getRuleContext(ParagraphContext.class,i); 3023 } 3024 public List<LiContext> li() { 3025 return getRuleContexts(LiContext.class); 3026 } 3027 public LiContext li(int i) { 3028 return getRuleContext(LiContext.class,i); 3029 } 3030 public List<TdContext> td() { 3031 return getRuleContexts(TdContext.class); 3032 } 3033 public TdContext td(int i) { 3034 return getRuleContext(TdContext.class,i); 3035 } 3036 public List<ThContext> th() { 3037 return getRuleContexts(ThContext.class); 3038 } 3039 public ThContext th(int i) { 3040 return getRuleContext(ThContext.class,i); 3041 } 3042 public List<BodyContext> body() { 3043 return getRuleContexts(BodyContext.class); 3044 } 3045 public BodyContext body(int i) { 3046 return getRuleContext(BodyContext.class,i); 3047 } 3048 public List<ColgroupContext> colgroup() { 3049 return getRuleContexts(ColgroupContext.class); 3050 } 3051 public ColgroupContext colgroup(int i) { 3052 return getRuleContext(ColgroupContext.class,i); 3053 } 3054 public List<DdContext> dd() { 3055 return getRuleContexts(DdContext.class); 3056 } 3057 public DdContext dd(int i) { 3058 return getRuleContext(DdContext.class,i); 3059 } 3060 public List<DtContext> dt() { 3061 return getRuleContexts(DtContext.class); 3062 } 3063 public DtContext dt(int i) { 3064 return getRuleContext(DtContext.class,i); 3065 } 3066 public List<HeadContext> head() { 3067 return getRuleContexts(HeadContext.class); 3068 } 3069 public HeadContext head(int i) { 3070 return getRuleContext(HeadContext.class,i); 3071 } 3072 public List<HtmlContext> html() { 3073 return getRuleContexts(HtmlContext.class); 3074 } 3075 public HtmlContext html(int i) { 3076 return getRuleContext(HtmlContext.class,i); 3077 } 3078 public List<OptionContext> option() { 3079 return getRuleContexts(OptionContext.class); 3080 } 3081 public OptionContext option(int i) { 3082 return getRuleContext(OptionContext.class,i); 3083 } 3084 public List<TbodyContext> tbody() { 3085 return getRuleContexts(TbodyContext.class); 3086 } 3087 public TbodyContext tbody(int i) { 3088 return getRuleContext(TbodyContext.class,i); 3089 } 3090 public List<TheadContext> thead() { 3091 return getRuleContexts(TheadContext.class); 3092 } 3093 public TheadContext thead(int i) { 3094 return getRuleContext(TheadContext.class,i); 3095 } 3096 public List<TfootContext> tfoot() { 3097 return getRuleContexts(TfootContext.class); 3098 } 3099 public TfootContext tfoot(int i) { 3100 return getRuleContext(TfootContext.class,i); 3101 } 3102 public List<PTagOpenContext> pTagOpen() { 3103 return getRuleContexts(PTagOpenContext.class); 3104 } 3105 public PTagOpenContext pTagOpen(int i) { 3106 return getRuleContext(PTagOpenContext.class,i); 3107 } 3108 public List<LiTagOpenContext> liTagOpen() { 3109 return getRuleContexts(LiTagOpenContext.class); 3110 } 3111 public LiTagOpenContext liTagOpen(int i) { 3112 return getRuleContext(LiTagOpenContext.class,i); 3113 } 3114 public List<TdTagOpenContext> tdTagOpen() { 3115 return getRuleContexts(TdTagOpenContext.class); 3116 } 3117 public TdTagOpenContext tdTagOpen(int i) { 3118 return getRuleContext(TdTagOpenContext.class,i); 3119 } 3120 public List<ThTagOpenContext> thTagOpen() { 3121 return getRuleContexts(ThTagOpenContext.class); 3122 } 3123 public ThTagOpenContext thTagOpen(int i) { 3124 return getRuleContext(ThTagOpenContext.class,i); 3125 } 3126 public List<BodyTagOpenContext> bodyTagOpen() { 3127 return getRuleContexts(BodyTagOpenContext.class); 3128 } 3129 public BodyTagOpenContext bodyTagOpen(int i) { 3130 return getRuleContext(BodyTagOpenContext.class,i); 3131 } 3132 public List<ColgroupTagOpenContext> colgroupTagOpen() { 3133 return getRuleContexts(ColgroupTagOpenContext.class); 3134 } 3135 public ColgroupTagOpenContext colgroupTagOpen(int i) { 3136 return getRuleContext(ColgroupTagOpenContext.class,i); 3137 } 3138 public List<DdTagOpenContext> ddTagOpen() { 3139 return getRuleContexts(DdTagOpenContext.class); 3140 } 3141 public DdTagOpenContext ddTagOpen(int i) { 3142 return getRuleContext(DdTagOpenContext.class,i); 3143 } 3144 public List<DtTagOpenContext> dtTagOpen() { 3145 return getRuleContexts(DtTagOpenContext.class); 3146 } 3147 public DtTagOpenContext dtTagOpen(int i) { 3148 return getRuleContext(DtTagOpenContext.class,i); 3149 } 3150 public List<HeadTagOpenContext> headTagOpen() { 3151 return getRuleContexts(HeadTagOpenContext.class); 3152 } 3153 public HeadTagOpenContext headTagOpen(int i) { 3154 return getRuleContext(HeadTagOpenContext.class,i); 3155 } 3156 public List<HtmlTagOpenContext> htmlTagOpen() { 3157 return getRuleContexts(HtmlTagOpenContext.class); 3158 } 3159 public HtmlTagOpenContext htmlTagOpen(int i) { 3160 return getRuleContext(HtmlTagOpenContext.class,i); 3161 } 3162 public List<OptionTagOpenContext> optionTagOpen() { 3163 return getRuleContexts(OptionTagOpenContext.class); 3164 } 3165 public OptionTagOpenContext optionTagOpen(int i) { 3166 return getRuleContext(OptionTagOpenContext.class,i); 3167 } 3168 public List<TbodyTagOpenContext> tbodyTagOpen() { 3169 return getRuleContexts(TbodyTagOpenContext.class); 3170 } 3171 public TbodyTagOpenContext tbodyTagOpen(int i) { 3172 return getRuleContext(TbodyTagOpenContext.class,i); 3173 } 3174 public List<TheadTagOpenContext> theadTagOpen() { 3175 return getRuleContexts(TheadTagOpenContext.class); 3176 } 3177 public TheadTagOpenContext theadTagOpen(int i) { 3178 return getRuleContext(TheadTagOpenContext.class,i); 3179 } 3180 public List<TfootTagOpenContext> tfootTagOpen() { 3181 return getRuleContexts(TfootTagOpenContext.class); 3182 } 3183 public TfootTagOpenContext tfootTagOpen(int i) { 3184 return getRuleContext(TfootTagOpenContext.class,i); 3185 } 3186 public List<HtmlCommentContext> htmlComment() { 3187 return getRuleContexts(HtmlCommentContext.class); 3188 } 3189 public HtmlCommentContext htmlComment(int i) { 3190 return getRuleContext(HtmlCommentContext.class,i); 3191 } 3192 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3193 public TerminalNode CDATA(int i) { 3194 return getToken(JavadocParser.CDATA, i); 3195 } 3196 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3197 public TerminalNode NEWLINE(int i) { 3198 return getToken(JavadocParser.NEWLINE, i); 3199 } 3200 public List<TextContext> text() { 3201 return getRuleContexts(TextContext.class); 3202 } 3203 public TextContext text(int i) { 3204 return getRuleContext(TextContext.class,i); 3205 } 3206 public List<JavadocInlineTagContext> javadocInlineTag() { 3207 return getRuleContexts(JavadocInlineTagContext.class); 3208 } 3209 public JavadocInlineTagContext javadocInlineTag(int i) { 3210 return getRuleContext(JavadocInlineTagContext.class,i); 3211 } 3212 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3213 public TerminalNode LEADING_ASTERISK(int i) { 3214 return getToken(JavadocParser.LEADING_ASTERISK, i); 3215 } 3216 public TrContext(ParserRuleContext parent, int invokingState) { 3217 super(parent, invokingState); 3218 } 3219 @Override public int getRuleIndex() { return RULE_tr; } 3220 @Override 3221 public void enterRule(ParseTreeListener listener) { 3222 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTr(this); 3223 } 3224 @Override 3225 public void exitRule(ParseTreeListener listener) { 3226 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTr(this); 3227 } 3228 @Override 3229 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3230 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTr(this); 3231 else return visitor.visitChildren(this); 3232 } 3233 } 3234 3235 public final TrContext tr() throws RecognitionException { 3236 TrContext _localctx = new TrContext(_ctx, getState()); 3237 enterRule(_localctx, 28, RULE_tr); 3238 try { 3239 int _alt; 3240 enterOuterAlt(_localctx, 1); 3241 { 3242 setState(468); 3243 trTagOpen(); 3244 setState(508); 3245 _errHandler.sync(this); 3246 _alt = getInterpreter().adaptivePredict(_input,31,_ctx); 3247 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3248 if ( _alt==1 ) { 3249 { 3250 setState(506); 3251 _errHandler.sync(this); 3252 switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) { 3253 case 1: 3254 { 3255 setState(469); 3256 htmlTag(); 3257 } 3258 break; 3259 case 2: 3260 { 3261 setState(470); 3262 singletonTag(); 3263 } 3264 break; 3265 case 3: 3266 { 3267 setState(471); 3268 paragraph(); 3269 } 3270 break; 3271 case 4: 3272 { 3273 setState(472); 3274 li(); 3275 } 3276 break; 3277 case 5: 3278 { 3279 setState(473); 3280 td(); 3281 } 3282 break; 3283 case 6: 3284 { 3285 setState(474); 3286 th(); 3287 } 3288 break; 3289 case 7: 3290 { 3291 setState(475); 3292 body(); 3293 } 3294 break; 3295 case 8: 3296 { 3297 setState(476); 3298 colgroup(); 3299 } 3300 break; 3301 case 9: 3302 { 3303 setState(477); 3304 dd(); 3305 } 3306 break; 3307 case 10: 3308 { 3309 setState(478); 3310 dt(); 3311 } 3312 break; 3313 case 11: 3314 { 3315 setState(479); 3316 head(); 3317 } 3318 break; 3319 case 12: 3320 { 3321 setState(480); 3322 html(); 3323 } 3324 break; 3325 case 13: 3326 { 3327 setState(481); 3328 option(); 3329 } 3330 break; 3331 case 14: 3332 { 3333 setState(482); 3334 tbody(); 3335 } 3336 break; 3337 case 15: 3338 { 3339 setState(483); 3340 thead(); 3341 } 3342 break; 3343 case 16: 3344 { 3345 setState(484); 3346 tfoot(); 3347 } 3348 break; 3349 case 17: 3350 { 3351 setState(485); 3352 pTagOpen(); 3353 } 3354 break; 3355 case 18: 3356 { 3357 setState(486); 3358 liTagOpen(); 3359 } 3360 break; 3361 case 19: 3362 { 3363 setState(487); 3364 tdTagOpen(); 3365 } 3366 break; 3367 case 20: 3368 { 3369 setState(488); 3370 thTagOpen(); 3371 } 3372 break; 3373 case 21: 3374 { 3375 setState(489); 3376 bodyTagOpen(); 3377 } 3378 break; 3379 case 22: 3380 { 3381 setState(490); 3382 colgroupTagOpen(); 3383 } 3384 break; 3385 case 23: 3386 { 3387 setState(491); 3388 ddTagOpen(); 3389 } 3390 break; 3391 case 24: 3392 { 3393 setState(492); 3394 dtTagOpen(); 3395 } 3396 break; 3397 case 25: 3398 { 3399 setState(493); 3400 headTagOpen(); 3401 } 3402 break; 3403 case 26: 3404 { 3405 setState(494); 3406 htmlTagOpen(); 3407 } 3408 break; 3409 case 27: 3410 { 3411 setState(495); 3412 optionTagOpen(); 3413 } 3414 break; 3415 case 28: 3416 { 3417 setState(496); 3418 tbodyTagOpen(); 3419 } 3420 break; 3421 case 29: 3422 { 3423 setState(497); 3424 theadTagOpen(); 3425 } 3426 break; 3427 case 30: 3428 { 3429 setState(498); 3430 tfootTagOpen(); 3431 } 3432 break; 3433 case 31: 3434 { 3435 { 3436 setState(499); 3437 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 3438 setState(500); 3439 match(LEADING_ASTERISK); 3440 } 3441 } 3442 break; 3443 case 32: 3444 { 3445 setState(501); 3446 htmlComment(); 3447 } 3448 break; 3449 case 33: 3450 { 3451 setState(502); 3452 match(CDATA); 3453 } 3454 break; 3455 case 34: 3456 { 3457 setState(503); 3458 match(NEWLINE); 3459 } 3460 break; 3461 case 35: 3462 { 3463 setState(504); 3464 text(); 3465 } 3466 break; 3467 case 36: 3468 { 3469 setState(505); 3470 javadocInlineTag(); 3471 } 3472 break; 3473 } 3474 } 3475 } 3476 setState(510); 3477 _errHandler.sync(this); 3478 _alt = getInterpreter().adaptivePredict(_input,31,_ctx); 3479 } 3480 setState(511); 3481 trTagClose(); 3482 } 3483 } 3484 catch (RecognitionException re) { 3485 _localctx.exception = re; 3486 _errHandler.reportError(this, re); 3487 _errHandler.recover(this, re); 3488 } 3489 finally { 3490 exitRule(); 3491 } 3492 return _localctx; 3493 } 3494 3495 public static class TdTagOpenContext extends ParserRuleContext { 3496 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 3497 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3498 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 3499 public List<AttributeContext> attribute() { 3500 return getRuleContexts(AttributeContext.class); 3501 } 3502 public AttributeContext attribute(int i) { 3503 return getRuleContext(AttributeContext.class,i); 3504 } 3505 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3506 public TerminalNode NEWLINE(int i) { 3507 return getToken(JavadocParser.NEWLINE, i); 3508 } 3509 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3510 public TerminalNode LEADING_ASTERISK(int i) { 3511 return getToken(JavadocParser.LEADING_ASTERISK, i); 3512 } 3513 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3514 public TerminalNode WS(int i) { 3515 return getToken(JavadocParser.WS, i); 3516 } 3517 public TdTagOpenContext(ParserRuleContext parent, int invokingState) { 3518 super(parent, invokingState); 3519 } 3520 @Override public int getRuleIndex() { return RULE_tdTagOpen; } 3521 @Override 3522 public void enterRule(ParseTreeListener listener) { 3523 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagOpen(this); 3524 } 3525 @Override 3526 public void exitRule(ParseTreeListener listener) { 3527 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagOpen(this); 3528 } 3529 @Override 3530 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3531 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagOpen(this); 3532 else return visitor.visitChildren(this); 3533 } 3534 } 3535 3536 public final TdTagOpenContext tdTagOpen() throws RecognitionException { 3537 TdTagOpenContext _localctx = new TdTagOpenContext(_ctx, getState()); 3538 enterRule(_localctx, 30, RULE_tdTagOpen); 3539 int _la; 3540 try { 3541 enterOuterAlt(_localctx, 1); 3542 { 3543 setState(513); 3544 match(OPEN); 3545 setState(514); 3546 match(TD_HTML_TAG_NAME); 3547 setState(521); 3548 _errHandler.sync(this); 3549 _la = _input.LA(1); 3550 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 3551 { 3552 setState(519); 3553 switch (_input.LA(1)) { 3554 case HTML_TAG_NAME: 3555 { 3556 setState(515); 3557 attribute(); 3558 } 3559 break; 3560 case NEWLINE: 3561 { 3562 setState(516); 3563 match(NEWLINE); 3564 } 3565 break; 3566 case LEADING_ASTERISK: 3567 { 3568 setState(517); 3569 match(LEADING_ASTERISK); 3570 } 3571 break; 3572 case WS: 3573 { 3574 setState(518); 3575 match(WS); 3576 } 3577 break; 3578 default: 3579 throw new NoViableAltException(this); 3580 } 3581 } 3582 setState(523); 3583 _errHandler.sync(this); 3584 _la = _input.LA(1); 3585 } 3586 setState(524); 3587 match(CLOSE); 3588 } 3589 } 3590 catch (RecognitionException re) { 3591 _localctx.exception = re; 3592 _errHandler.reportError(this, re); 3593 _errHandler.recover(this, re); 3594 } 3595 finally { 3596 exitRule(); 3597 } 3598 return _localctx; 3599 } 3600 3601 public static class TdTagCloseContext extends ParserRuleContext { 3602 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 3603 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 3604 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 3605 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 3606 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3607 public TerminalNode NEWLINE(int i) { 3608 return getToken(JavadocParser.NEWLINE, i); 3609 } 3610 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3611 public TerminalNode LEADING_ASTERISK(int i) { 3612 return getToken(JavadocParser.LEADING_ASTERISK, i); 3613 } 3614 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 3615 public TerminalNode WS(int i) { 3616 return getToken(JavadocParser.WS, i); 3617 } 3618 public TdTagCloseContext(ParserRuleContext parent, int invokingState) { 3619 super(parent, invokingState); 3620 } 3621 @Override public int getRuleIndex() { return RULE_tdTagClose; } 3622 @Override 3623 public void enterRule(ParseTreeListener listener) { 3624 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTdTagClose(this); 3625 } 3626 @Override 3627 public void exitRule(ParseTreeListener listener) { 3628 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTdTagClose(this); 3629 } 3630 @Override 3631 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3632 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagClose(this); 3633 else return visitor.visitChildren(this); 3634 } 3635 } 3636 3637 public final TdTagCloseContext tdTagClose() throws RecognitionException { 3638 TdTagCloseContext _localctx = new TdTagCloseContext(_ctx, getState()); 3639 enterRule(_localctx, 32, RULE_tdTagClose); 3640 int _la; 3641 try { 3642 enterOuterAlt(_localctx, 1); 3643 { 3644 setState(526); 3645 match(OPEN); 3646 setState(527); 3647 match(SLASH); 3648 setState(528); 3649 match(TD_HTML_TAG_NAME); 3650 setState(532); 3651 _errHandler.sync(this); 3652 _la = _input.LA(1); 3653 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 3654 { 3655 { 3656 setState(529); 3657 _la = _input.LA(1); 3658 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 3659 _errHandler.recoverInline(this); 3660 } else { 3661 consume(); 3662 } 3663 } 3664 } 3665 setState(534); 3666 _errHandler.sync(this); 3667 _la = _input.LA(1); 3668 } 3669 setState(535); 3670 match(CLOSE); 3671 } 3672 } 3673 catch (RecognitionException re) { 3674 _localctx.exception = re; 3675 _errHandler.reportError(this, re); 3676 _errHandler.recover(this, re); 3677 } 3678 finally { 3679 exitRule(); 3680 } 3681 return _localctx; 3682 } 3683 3684 public static class TdContext extends ParserRuleContext { 3685 public List<TdTagOpenContext> tdTagOpen() { 3686 return getRuleContexts(TdTagOpenContext.class); 3687 } 3688 public TdTagOpenContext tdTagOpen(int i) { 3689 return getRuleContext(TdTagOpenContext.class,i); 3690 } 3691 public TdTagCloseContext tdTagClose() { 3692 return getRuleContext(TdTagCloseContext.class,0); 3693 } 3694 public List<HtmlTagContext> htmlTag() { 3695 return getRuleContexts(HtmlTagContext.class); 3696 } 3697 public HtmlTagContext htmlTag(int i) { 3698 return getRuleContext(HtmlTagContext.class,i); 3699 } 3700 public List<SingletonTagContext> singletonTag() { 3701 return getRuleContexts(SingletonTagContext.class); 3702 } 3703 public SingletonTagContext singletonTag(int i) { 3704 return getRuleContext(SingletonTagContext.class,i); 3705 } 3706 public List<ParagraphContext> paragraph() { 3707 return getRuleContexts(ParagraphContext.class); 3708 } 3709 public ParagraphContext paragraph(int i) { 3710 return getRuleContext(ParagraphContext.class,i); 3711 } 3712 public List<LiContext> li() { 3713 return getRuleContexts(LiContext.class); 3714 } 3715 public LiContext li(int i) { 3716 return getRuleContext(LiContext.class,i); 3717 } 3718 public List<TrContext> tr() { 3719 return getRuleContexts(TrContext.class); 3720 } 3721 public TrContext tr(int i) { 3722 return getRuleContext(TrContext.class,i); 3723 } 3724 public List<ThContext> th() { 3725 return getRuleContexts(ThContext.class); 3726 } 3727 public ThContext th(int i) { 3728 return getRuleContext(ThContext.class,i); 3729 } 3730 public List<BodyContext> body() { 3731 return getRuleContexts(BodyContext.class); 3732 } 3733 public BodyContext body(int i) { 3734 return getRuleContext(BodyContext.class,i); 3735 } 3736 public List<ColgroupContext> colgroup() { 3737 return getRuleContexts(ColgroupContext.class); 3738 } 3739 public ColgroupContext colgroup(int i) { 3740 return getRuleContext(ColgroupContext.class,i); 3741 } 3742 public List<DdContext> dd() { 3743 return getRuleContexts(DdContext.class); 3744 } 3745 public DdContext dd(int i) { 3746 return getRuleContext(DdContext.class,i); 3747 } 3748 public List<DtContext> dt() { 3749 return getRuleContexts(DtContext.class); 3750 } 3751 public DtContext dt(int i) { 3752 return getRuleContext(DtContext.class,i); 3753 } 3754 public List<HeadContext> head() { 3755 return getRuleContexts(HeadContext.class); 3756 } 3757 public HeadContext head(int i) { 3758 return getRuleContext(HeadContext.class,i); 3759 } 3760 public List<HtmlContext> html() { 3761 return getRuleContexts(HtmlContext.class); 3762 } 3763 public HtmlContext html(int i) { 3764 return getRuleContext(HtmlContext.class,i); 3765 } 3766 public List<OptionContext> option() { 3767 return getRuleContexts(OptionContext.class); 3768 } 3769 public OptionContext option(int i) { 3770 return getRuleContext(OptionContext.class,i); 3771 } 3772 public List<TbodyContext> tbody() { 3773 return getRuleContexts(TbodyContext.class); 3774 } 3775 public TbodyContext tbody(int i) { 3776 return getRuleContext(TbodyContext.class,i); 3777 } 3778 public List<TheadContext> thead() { 3779 return getRuleContexts(TheadContext.class); 3780 } 3781 public TheadContext thead(int i) { 3782 return getRuleContext(TheadContext.class,i); 3783 } 3784 public List<TfootContext> tfoot() { 3785 return getRuleContexts(TfootContext.class); 3786 } 3787 public TfootContext tfoot(int i) { 3788 return getRuleContext(TfootContext.class,i); 3789 } 3790 public List<PTagOpenContext> pTagOpen() { 3791 return getRuleContexts(PTagOpenContext.class); 3792 } 3793 public PTagOpenContext pTagOpen(int i) { 3794 return getRuleContext(PTagOpenContext.class,i); 3795 } 3796 public List<LiTagOpenContext> liTagOpen() { 3797 return getRuleContexts(LiTagOpenContext.class); 3798 } 3799 public LiTagOpenContext liTagOpen(int i) { 3800 return getRuleContext(LiTagOpenContext.class,i); 3801 } 3802 public List<ThTagOpenContext> thTagOpen() { 3803 return getRuleContexts(ThTagOpenContext.class); 3804 } 3805 public ThTagOpenContext thTagOpen(int i) { 3806 return getRuleContext(ThTagOpenContext.class,i); 3807 } 3808 public List<BodyTagOpenContext> bodyTagOpen() { 3809 return getRuleContexts(BodyTagOpenContext.class); 3810 } 3811 public BodyTagOpenContext bodyTagOpen(int i) { 3812 return getRuleContext(BodyTagOpenContext.class,i); 3813 } 3814 public List<ColgroupTagOpenContext> colgroupTagOpen() { 3815 return getRuleContexts(ColgroupTagOpenContext.class); 3816 } 3817 public ColgroupTagOpenContext colgroupTagOpen(int i) { 3818 return getRuleContext(ColgroupTagOpenContext.class,i); 3819 } 3820 public List<DdTagOpenContext> ddTagOpen() { 3821 return getRuleContexts(DdTagOpenContext.class); 3822 } 3823 public DdTagOpenContext ddTagOpen(int i) { 3824 return getRuleContext(DdTagOpenContext.class,i); 3825 } 3826 public List<DtTagOpenContext> dtTagOpen() { 3827 return getRuleContexts(DtTagOpenContext.class); 3828 } 3829 public DtTagOpenContext dtTagOpen(int i) { 3830 return getRuleContext(DtTagOpenContext.class,i); 3831 } 3832 public List<HeadTagOpenContext> headTagOpen() { 3833 return getRuleContexts(HeadTagOpenContext.class); 3834 } 3835 public HeadTagOpenContext headTagOpen(int i) { 3836 return getRuleContext(HeadTagOpenContext.class,i); 3837 } 3838 public List<HtmlTagOpenContext> htmlTagOpen() { 3839 return getRuleContexts(HtmlTagOpenContext.class); 3840 } 3841 public HtmlTagOpenContext htmlTagOpen(int i) { 3842 return getRuleContext(HtmlTagOpenContext.class,i); 3843 } 3844 public List<OptionTagOpenContext> optionTagOpen() { 3845 return getRuleContexts(OptionTagOpenContext.class); 3846 } 3847 public OptionTagOpenContext optionTagOpen(int i) { 3848 return getRuleContext(OptionTagOpenContext.class,i); 3849 } 3850 public List<TbodyTagOpenContext> tbodyTagOpen() { 3851 return getRuleContexts(TbodyTagOpenContext.class); 3852 } 3853 public TbodyTagOpenContext tbodyTagOpen(int i) { 3854 return getRuleContext(TbodyTagOpenContext.class,i); 3855 } 3856 public List<TheadTagOpenContext> theadTagOpen() { 3857 return getRuleContexts(TheadTagOpenContext.class); 3858 } 3859 public TheadTagOpenContext theadTagOpen(int i) { 3860 return getRuleContext(TheadTagOpenContext.class,i); 3861 } 3862 public List<TfootTagOpenContext> tfootTagOpen() { 3863 return getRuleContexts(TfootTagOpenContext.class); 3864 } 3865 public TfootTagOpenContext tfootTagOpen(int i) { 3866 return getRuleContext(TfootTagOpenContext.class,i); 3867 } 3868 public List<HtmlCommentContext> htmlComment() { 3869 return getRuleContexts(HtmlCommentContext.class); 3870 } 3871 public HtmlCommentContext htmlComment(int i) { 3872 return getRuleContext(HtmlCommentContext.class,i); 3873 } 3874 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 3875 public TerminalNode CDATA(int i) { 3876 return getToken(JavadocParser.CDATA, i); 3877 } 3878 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 3879 public TerminalNode NEWLINE(int i) { 3880 return getToken(JavadocParser.NEWLINE, i); 3881 } 3882 public List<TextContext> text() { 3883 return getRuleContexts(TextContext.class); 3884 } 3885 public TextContext text(int i) { 3886 return getRuleContext(TextContext.class,i); 3887 } 3888 public List<JavadocInlineTagContext> javadocInlineTag() { 3889 return getRuleContexts(JavadocInlineTagContext.class); 3890 } 3891 public JavadocInlineTagContext javadocInlineTag(int i) { 3892 return getRuleContext(JavadocInlineTagContext.class,i); 3893 } 3894 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 3895 public TerminalNode LEADING_ASTERISK(int i) { 3896 return getToken(JavadocParser.LEADING_ASTERISK, i); 3897 } 3898 public TdContext(ParserRuleContext parent, int invokingState) { 3899 super(parent, invokingState); 3900 } 3901 @Override public int getRuleIndex() { return RULE_td; } 3902 @Override 3903 public void enterRule(ParseTreeListener listener) { 3904 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTd(this); 3905 } 3906 @Override 3907 public void exitRule(ParseTreeListener listener) { 3908 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTd(this); 3909 } 3910 @Override 3911 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 3912 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTd(this); 3913 else return visitor.visitChildren(this); 3914 } 3915 } 3916 3917 public final TdContext td() throws RecognitionException { 3918 TdContext _localctx = new TdContext(_ctx, getState()); 3919 enterRule(_localctx, 34, RULE_td); 3920 try { 3921 int _alt; 3922 enterOuterAlt(_localctx, 1); 3923 { 3924 setState(537); 3925 tdTagOpen(); 3926 setState(577); 3927 _errHandler.sync(this); 3928 _alt = getInterpreter().adaptivePredict(_input,36,_ctx); 3929 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 3930 if ( _alt==1 ) { 3931 { 3932 setState(575); 3933 _errHandler.sync(this); 3934 switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { 3935 case 1: 3936 { 3937 setState(538); 3938 htmlTag(); 3939 } 3940 break; 3941 case 2: 3942 { 3943 setState(539); 3944 singletonTag(); 3945 } 3946 break; 3947 case 3: 3948 { 3949 setState(540); 3950 paragraph(); 3951 } 3952 break; 3953 case 4: 3954 { 3955 setState(541); 3956 li(); 3957 } 3958 break; 3959 case 5: 3960 { 3961 setState(542); 3962 tr(); 3963 } 3964 break; 3965 case 6: 3966 { 3967 setState(543); 3968 th(); 3969 } 3970 break; 3971 case 7: 3972 { 3973 setState(544); 3974 body(); 3975 } 3976 break; 3977 case 8: 3978 { 3979 setState(545); 3980 colgroup(); 3981 } 3982 break; 3983 case 9: 3984 { 3985 setState(546); 3986 dd(); 3987 } 3988 break; 3989 case 10: 3990 { 3991 setState(547); 3992 dt(); 3993 } 3994 break; 3995 case 11: 3996 { 3997 setState(548); 3998 head(); 3999 } 4000 break; 4001 case 12: 4002 { 4003 setState(549); 4004 html(); 4005 } 4006 break; 4007 case 13: 4008 { 4009 setState(550); 4010 option(); 4011 } 4012 break; 4013 case 14: 4014 { 4015 setState(551); 4016 tbody(); 4017 } 4018 break; 4019 case 15: 4020 { 4021 setState(552); 4022 thead(); 4023 } 4024 break; 4025 case 16: 4026 { 4027 setState(553); 4028 tfoot(); 4029 } 4030 break; 4031 case 17: 4032 { 4033 setState(554); 4034 pTagOpen(); 4035 } 4036 break; 4037 case 18: 4038 { 4039 setState(555); 4040 liTagOpen(); 4041 } 4042 break; 4043 case 19: 4044 { 4045 setState(556); 4046 tdTagOpen(); 4047 } 4048 break; 4049 case 20: 4050 { 4051 setState(557); 4052 thTagOpen(); 4053 } 4054 break; 4055 case 21: 4056 { 4057 setState(558); 4058 bodyTagOpen(); 4059 } 4060 break; 4061 case 22: 4062 { 4063 setState(559); 4064 colgroupTagOpen(); 4065 } 4066 break; 4067 case 23: 4068 { 4069 setState(560); 4070 ddTagOpen(); 4071 } 4072 break; 4073 case 24: 4074 { 4075 setState(561); 4076 dtTagOpen(); 4077 } 4078 break; 4079 case 25: 4080 { 4081 setState(562); 4082 headTagOpen(); 4083 } 4084 break; 4085 case 26: 4086 { 4087 setState(563); 4088 htmlTagOpen(); 4089 } 4090 break; 4091 case 27: 4092 { 4093 setState(564); 4094 optionTagOpen(); 4095 } 4096 break; 4097 case 28: 4098 { 4099 setState(565); 4100 tbodyTagOpen(); 4101 } 4102 break; 4103 case 29: 4104 { 4105 setState(566); 4106 theadTagOpen(); 4107 } 4108 break; 4109 case 30: 4110 { 4111 setState(567); 4112 tfootTagOpen(); 4113 } 4114 break; 4115 case 31: 4116 { 4117 { 4118 setState(568); 4119 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4120 setState(569); 4121 match(LEADING_ASTERISK); 4122 } 4123 } 4124 break; 4125 case 32: 4126 { 4127 setState(570); 4128 htmlComment(); 4129 } 4130 break; 4131 case 33: 4132 { 4133 setState(571); 4134 match(CDATA); 4135 } 4136 break; 4137 case 34: 4138 { 4139 setState(572); 4140 match(NEWLINE); 4141 } 4142 break; 4143 case 35: 4144 { 4145 setState(573); 4146 text(); 4147 } 4148 break; 4149 case 36: 4150 { 4151 setState(574); 4152 javadocInlineTag(); 4153 } 4154 break; 4155 } 4156 } 4157 } 4158 setState(579); 4159 _errHandler.sync(this); 4160 _alt = getInterpreter().adaptivePredict(_input,36,_ctx); 4161 } 4162 setState(580); 4163 tdTagClose(); 4164 } 4165 } 4166 catch (RecognitionException re) { 4167 _localctx.exception = re; 4168 _errHandler.reportError(this, re); 4169 _errHandler.recover(this, re); 4170 } 4171 finally { 4172 exitRule(); 4173 } 4174 return _localctx; 4175 } 4176 4177 public static class ThTagOpenContext extends ParserRuleContext { 4178 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4179 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4180 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4181 public List<AttributeContext> attribute() { 4182 return getRuleContexts(AttributeContext.class); 4183 } 4184 public AttributeContext attribute(int i) { 4185 return getRuleContext(AttributeContext.class,i); 4186 } 4187 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4188 public TerminalNode NEWLINE(int i) { 4189 return getToken(JavadocParser.NEWLINE, i); 4190 } 4191 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4192 public TerminalNode LEADING_ASTERISK(int i) { 4193 return getToken(JavadocParser.LEADING_ASTERISK, i); 4194 } 4195 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4196 public TerminalNode WS(int i) { 4197 return getToken(JavadocParser.WS, i); 4198 } 4199 public ThTagOpenContext(ParserRuleContext parent, int invokingState) { 4200 super(parent, invokingState); 4201 } 4202 @Override public int getRuleIndex() { return RULE_thTagOpen; } 4203 @Override 4204 public void enterRule(ParseTreeListener listener) { 4205 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagOpen(this); 4206 } 4207 @Override 4208 public void exitRule(ParseTreeListener listener) { 4209 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagOpen(this); 4210 } 4211 @Override 4212 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4213 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagOpen(this); 4214 else return visitor.visitChildren(this); 4215 } 4216 } 4217 4218 public final ThTagOpenContext thTagOpen() throws RecognitionException { 4219 ThTagOpenContext _localctx = new ThTagOpenContext(_ctx, getState()); 4220 enterRule(_localctx, 36, RULE_thTagOpen); 4221 int _la; 4222 try { 4223 enterOuterAlt(_localctx, 1); 4224 { 4225 setState(582); 4226 match(OPEN); 4227 setState(583); 4228 match(TH_HTML_TAG_NAME); 4229 setState(590); 4230 _errHandler.sync(this); 4231 _la = _input.LA(1); 4232 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4233 { 4234 setState(588); 4235 switch (_input.LA(1)) { 4236 case HTML_TAG_NAME: 4237 { 4238 setState(584); 4239 attribute(); 4240 } 4241 break; 4242 case NEWLINE: 4243 { 4244 setState(585); 4245 match(NEWLINE); 4246 } 4247 break; 4248 case LEADING_ASTERISK: 4249 { 4250 setState(586); 4251 match(LEADING_ASTERISK); 4252 } 4253 break; 4254 case WS: 4255 { 4256 setState(587); 4257 match(WS); 4258 } 4259 break; 4260 default: 4261 throw new NoViableAltException(this); 4262 } 4263 } 4264 setState(592); 4265 _errHandler.sync(this); 4266 _la = _input.LA(1); 4267 } 4268 setState(593); 4269 match(CLOSE); 4270 } 4271 } 4272 catch (RecognitionException re) { 4273 _localctx.exception = re; 4274 _errHandler.reportError(this, re); 4275 _errHandler.recover(this, re); 4276 } 4277 finally { 4278 exitRule(); 4279 } 4280 return _localctx; 4281 } 4282 4283 public static class ThTagCloseContext extends ParserRuleContext { 4284 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4285 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4286 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 4287 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4288 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4289 public TerminalNode NEWLINE(int i) { 4290 return getToken(JavadocParser.NEWLINE, i); 4291 } 4292 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4293 public TerminalNode LEADING_ASTERISK(int i) { 4294 return getToken(JavadocParser.LEADING_ASTERISK, i); 4295 } 4296 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4297 public TerminalNode WS(int i) { 4298 return getToken(JavadocParser.WS, i); 4299 } 4300 public ThTagCloseContext(ParserRuleContext parent, int invokingState) { 4301 super(parent, invokingState); 4302 } 4303 @Override public int getRuleIndex() { return RULE_thTagClose; } 4304 @Override 4305 public void enterRule(ParseTreeListener listener) { 4306 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThTagClose(this); 4307 } 4308 @Override 4309 public void exitRule(ParseTreeListener listener) { 4310 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThTagClose(this); 4311 } 4312 @Override 4313 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4314 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagClose(this); 4315 else return visitor.visitChildren(this); 4316 } 4317 } 4318 4319 public final ThTagCloseContext thTagClose() throws RecognitionException { 4320 ThTagCloseContext _localctx = new ThTagCloseContext(_ctx, getState()); 4321 enterRule(_localctx, 38, RULE_thTagClose); 4322 int _la; 4323 try { 4324 enterOuterAlt(_localctx, 1); 4325 { 4326 setState(595); 4327 match(OPEN); 4328 setState(596); 4329 match(SLASH); 4330 setState(597); 4331 match(TH_HTML_TAG_NAME); 4332 setState(601); 4333 _errHandler.sync(this); 4334 _la = _input.LA(1); 4335 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 4336 { 4337 { 4338 setState(598); 4339 _la = _input.LA(1); 4340 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 4341 _errHandler.recoverInline(this); 4342 } else { 4343 consume(); 4344 } 4345 } 4346 } 4347 setState(603); 4348 _errHandler.sync(this); 4349 _la = _input.LA(1); 4350 } 4351 setState(604); 4352 match(CLOSE); 4353 } 4354 } 4355 catch (RecognitionException re) { 4356 _localctx.exception = re; 4357 _errHandler.reportError(this, re); 4358 _errHandler.recover(this, re); 4359 } 4360 finally { 4361 exitRule(); 4362 } 4363 return _localctx; 4364 } 4365 4366 public static class ThContext extends ParserRuleContext { 4367 public ThTagOpenContext thTagOpen() { 4368 return getRuleContext(ThTagOpenContext.class,0); 4369 } 4370 public ThTagCloseContext thTagClose() { 4371 return getRuleContext(ThTagCloseContext.class,0); 4372 } 4373 public List<HtmlTagContext> htmlTag() { 4374 return getRuleContexts(HtmlTagContext.class); 4375 } 4376 public HtmlTagContext htmlTag(int i) { 4377 return getRuleContext(HtmlTagContext.class,i); 4378 } 4379 public List<SingletonTagContext> singletonTag() { 4380 return getRuleContexts(SingletonTagContext.class); 4381 } 4382 public SingletonTagContext singletonTag(int i) { 4383 return getRuleContext(SingletonTagContext.class,i); 4384 } 4385 public List<ParagraphContext> paragraph() { 4386 return getRuleContexts(ParagraphContext.class); 4387 } 4388 public ParagraphContext paragraph(int i) { 4389 return getRuleContext(ParagraphContext.class,i); 4390 } 4391 public List<LiContext> li() { 4392 return getRuleContexts(LiContext.class); 4393 } 4394 public LiContext li(int i) { 4395 return getRuleContext(LiContext.class,i); 4396 } 4397 public List<TrContext> tr() { 4398 return getRuleContexts(TrContext.class); 4399 } 4400 public TrContext tr(int i) { 4401 return getRuleContext(TrContext.class,i); 4402 } 4403 public List<TdContext> td() { 4404 return getRuleContexts(TdContext.class); 4405 } 4406 public TdContext td(int i) { 4407 return getRuleContext(TdContext.class,i); 4408 } 4409 public List<BodyContext> body() { 4410 return getRuleContexts(BodyContext.class); 4411 } 4412 public BodyContext body(int i) { 4413 return getRuleContext(BodyContext.class,i); 4414 } 4415 public List<ColgroupContext> colgroup() { 4416 return getRuleContexts(ColgroupContext.class); 4417 } 4418 public ColgroupContext colgroup(int i) { 4419 return getRuleContext(ColgroupContext.class,i); 4420 } 4421 public List<DdContext> dd() { 4422 return getRuleContexts(DdContext.class); 4423 } 4424 public DdContext dd(int i) { 4425 return getRuleContext(DdContext.class,i); 4426 } 4427 public List<DtContext> dt() { 4428 return getRuleContexts(DtContext.class); 4429 } 4430 public DtContext dt(int i) { 4431 return getRuleContext(DtContext.class,i); 4432 } 4433 public List<HeadContext> head() { 4434 return getRuleContexts(HeadContext.class); 4435 } 4436 public HeadContext head(int i) { 4437 return getRuleContext(HeadContext.class,i); 4438 } 4439 public List<HtmlContext> html() { 4440 return getRuleContexts(HtmlContext.class); 4441 } 4442 public HtmlContext html(int i) { 4443 return getRuleContext(HtmlContext.class,i); 4444 } 4445 public List<OptionContext> option() { 4446 return getRuleContexts(OptionContext.class); 4447 } 4448 public OptionContext option(int i) { 4449 return getRuleContext(OptionContext.class,i); 4450 } 4451 public List<TbodyContext> tbody() { 4452 return getRuleContexts(TbodyContext.class); 4453 } 4454 public TbodyContext tbody(int i) { 4455 return getRuleContext(TbodyContext.class,i); 4456 } 4457 public List<TheadContext> thead() { 4458 return getRuleContexts(TheadContext.class); 4459 } 4460 public TheadContext thead(int i) { 4461 return getRuleContext(TheadContext.class,i); 4462 } 4463 public List<TfootContext> tfoot() { 4464 return getRuleContexts(TfootContext.class); 4465 } 4466 public TfootContext tfoot(int i) { 4467 return getRuleContext(TfootContext.class,i); 4468 } 4469 public List<PTagOpenContext> pTagOpen() { 4470 return getRuleContexts(PTagOpenContext.class); 4471 } 4472 public PTagOpenContext pTagOpen(int i) { 4473 return getRuleContext(PTagOpenContext.class,i); 4474 } 4475 public List<LiTagOpenContext> liTagOpen() { 4476 return getRuleContexts(LiTagOpenContext.class); 4477 } 4478 public LiTagOpenContext liTagOpen(int i) { 4479 return getRuleContext(LiTagOpenContext.class,i); 4480 } 4481 public List<TrTagOpenContext> trTagOpen() { 4482 return getRuleContexts(TrTagOpenContext.class); 4483 } 4484 public TrTagOpenContext trTagOpen(int i) { 4485 return getRuleContext(TrTagOpenContext.class,i); 4486 } 4487 public List<TdTagOpenContext> tdTagOpen() { 4488 return getRuleContexts(TdTagOpenContext.class); 4489 } 4490 public TdTagOpenContext tdTagOpen(int i) { 4491 return getRuleContext(TdTagOpenContext.class,i); 4492 } 4493 public List<BodyTagOpenContext> bodyTagOpen() { 4494 return getRuleContexts(BodyTagOpenContext.class); 4495 } 4496 public BodyTagOpenContext bodyTagOpen(int i) { 4497 return getRuleContext(BodyTagOpenContext.class,i); 4498 } 4499 public List<ColgroupTagOpenContext> colgroupTagOpen() { 4500 return getRuleContexts(ColgroupTagOpenContext.class); 4501 } 4502 public ColgroupTagOpenContext colgroupTagOpen(int i) { 4503 return getRuleContext(ColgroupTagOpenContext.class,i); 4504 } 4505 public List<DdTagOpenContext> ddTagOpen() { 4506 return getRuleContexts(DdTagOpenContext.class); 4507 } 4508 public DdTagOpenContext ddTagOpen(int i) { 4509 return getRuleContext(DdTagOpenContext.class,i); 4510 } 4511 public List<DtTagOpenContext> dtTagOpen() { 4512 return getRuleContexts(DtTagOpenContext.class); 4513 } 4514 public DtTagOpenContext dtTagOpen(int i) { 4515 return getRuleContext(DtTagOpenContext.class,i); 4516 } 4517 public List<HeadTagOpenContext> headTagOpen() { 4518 return getRuleContexts(HeadTagOpenContext.class); 4519 } 4520 public HeadTagOpenContext headTagOpen(int i) { 4521 return getRuleContext(HeadTagOpenContext.class,i); 4522 } 4523 public List<HtmlTagOpenContext> htmlTagOpen() { 4524 return getRuleContexts(HtmlTagOpenContext.class); 4525 } 4526 public HtmlTagOpenContext htmlTagOpen(int i) { 4527 return getRuleContext(HtmlTagOpenContext.class,i); 4528 } 4529 public List<OptionTagOpenContext> optionTagOpen() { 4530 return getRuleContexts(OptionTagOpenContext.class); 4531 } 4532 public OptionTagOpenContext optionTagOpen(int i) { 4533 return getRuleContext(OptionTagOpenContext.class,i); 4534 } 4535 public List<TbodyTagOpenContext> tbodyTagOpen() { 4536 return getRuleContexts(TbodyTagOpenContext.class); 4537 } 4538 public TbodyTagOpenContext tbodyTagOpen(int i) { 4539 return getRuleContext(TbodyTagOpenContext.class,i); 4540 } 4541 public List<TheadTagOpenContext> theadTagOpen() { 4542 return getRuleContexts(TheadTagOpenContext.class); 4543 } 4544 public TheadTagOpenContext theadTagOpen(int i) { 4545 return getRuleContext(TheadTagOpenContext.class,i); 4546 } 4547 public List<TfootTagOpenContext> tfootTagOpen() { 4548 return getRuleContexts(TfootTagOpenContext.class); 4549 } 4550 public TfootTagOpenContext tfootTagOpen(int i) { 4551 return getRuleContext(TfootTagOpenContext.class,i); 4552 } 4553 public List<HtmlCommentContext> htmlComment() { 4554 return getRuleContexts(HtmlCommentContext.class); 4555 } 4556 public HtmlCommentContext htmlComment(int i) { 4557 return getRuleContext(HtmlCommentContext.class,i); 4558 } 4559 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 4560 public TerminalNode CDATA(int i) { 4561 return getToken(JavadocParser.CDATA, i); 4562 } 4563 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4564 public TerminalNode NEWLINE(int i) { 4565 return getToken(JavadocParser.NEWLINE, i); 4566 } 4567 public List<TextContext> text() { 4568 return getRuleContexts(TextContext.class); 4569 } 4570 public TextContext text(int i) { 4571 return getRuleContext(TextContext.class,i); 4572 } 4573 public List<JavadocInlineTagContext> javadocInlineTag() { 4574 return getRuleContexts(JavadocInlineTagContext.class); 4575 } 4576 public JavadocInlineTagContext javadocInlineTag(int i) { 4577 return getRuleContext(JavadocInlineTagContext.class,i); 4578 } 4579 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4580 public TerminalNode LEADING_ASTERISK(int i) { 4581 return getToken(JavadocParser.LEADING_ASTERISK, i); 4582 } 4583 public ThContext(ParserRuleContext parent, int invokingState) { 4584 super(parent, invokingState); 4585 } 4586 @Override public int getRuleIndex() { return RULE_th; } 4587 @Override 4588 public void enterRule(ParseTreeListener listener) { 4589 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTh(this); 4590 } 4591 @Override 4592 public void exitRule(ParseTreeListener listener) { 4593 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTh(this); 4594 } 4595 @Override 4596 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4597 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTh(this); 4598 else return visitor.visitChildren(this); 4599 } 4600 } 4601 4602 public final ThContext th() throws RecognitionException { 4603 ThContext _localctx = new ThContext(_ctx, getState()); 4604 enterRule(_localctx, 40, RULE_th); 4605 try { 4606 int _alt; 4607 enterOuterAlt(_localctx, 1); 4608 { 4609 setState(606); 4610 thTagOpen(); 4611 setState(646); 4612 _errHandler.sync(this); 4613 _alt = getInterpreter().adaptivePredict(_input,41,_ctx); 4614 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 4615 if ( _alt==1 ) { 4616 { 4617 setState(644); 4618 _errHandler.sync(this); 4619 switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { 4620 case 1: 4621 { 4622 setState(607); 4623 htmlTag(); 4624 } 4625 break; 4626 case 2: 4627 { 4628 setState(608); 4629 singletonTag(); 4630 } 4631 break; 4632 case 3: 4633 { 4634 setState(609); 4635 paragraph(); 4636 } 4637 break; 4638 case 4: 4639 { 4640 setState(610); 4641 li(); 4642 } 4643 break; 4644 case 5: 4645 { 4646 setState(611); 4647 tr(); 4648 } 4649 break; 4650 case 6: 4651 { 4652 setState(612); 4653 td(); 4654 } 4655 break; 4656 case 7: 4657 { 4658 setState(613); 4659 body(); 4660 } 4661 break; 4662 case 8: 4663 { 4664 setState(614); 4665 colgroup(); 4666 } 4667 break; 4668 case 9: 4669 { 4670 setState(615); 4671 dd(); 4672 } 4673 break; 4674 case 10: 4675 { 4676 setState(616); 4677 dt(); 4678 } 4679 break; 4680 case 11: 4681 { 4682 setState(617); 4683 head(); 4684 } 4685 break; 4686 case 12: 4687 { 4688 setState(618); 4689 html(); 4690 } 4691 break; 4692 case 13: 4693 { 4694 setState(619); 4695 option(); 4696 } 4697 break; 4698 case 14: 4699 { 4700 setState(620); 4701 tbody(); 4702 } 4703 break; 4704 case 15: 4705 { 4706 setState(621); 4707 thead(); 4708 } 4709 break; 4710 case 16: 4711 { 4712 setState(622); 4713 tfoot(); 4714 } 4715 break; 4716 case 17: 4717 { 4718 setState(623); 4719 pTagOpen(); 4720 } 4721 break; 4722 case 18: 4723 { 4724 setState(624); 4725 liTagOpen(); 4726 } 4727 break; 4728 case 19: 4729 { 4730 setState(625); 4731 trTagOpen(); 4732 } 4733 break; 4734 case 20: 4735 { 4736 setState(626); 4737 tdTagOpen(); 4738 } 4739 break; 4740 case 21: 4741 { 4742 setState(627); 4743 bodyTagOpen(); 4744 } 4745 break; 4746 case 22: 4747 { 4748 setState(628); 4749 colgroupTagOpen(); 4750 } 4751 break; 4752 case 23: 4753 { 4754 setState(629); 4755 ddTagOpen(); 4756 } 4757 break; 4758 case 24: 4759 { 4760 setState(630); 4761 dtTagOpen(); 4762 } 4763 break; 4764 case 25: 4765 { 4766 setState(631); 4767 headTagOpen(); 4768 } 4769 break; 4770 case 26: 4771 { 4772 setState(632); 4773 htmlTagOpen(); 4774 } 4775 break; 4776 case 27: 4777 { 4778 setState(633); 4779 optionTagOpen(); 4780 } 4781 break; 4782 case 28: 4783 { 4784 setState(634); 4785 tbodyTagOpen(); 4786 } 4787 break; 4788 case 29: 4789 { 4790 setState(635); 4791 theadTagOpen(); 4792 } 4793 break; 4794 case 30: 4795 { 4796 setState(636); 4797 tfootTagOpen(); 4798 } 4799 break; 4800 case 31: 4801 { 4802 { 4803 setState(637); 4804 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 4805 setState(638); 4806 match(LEADING_ASTERISK); 4807 } 4808 } 4809 break; 4810 case 32: 4811 { 4812 setState(639); 4813 htmlComment(); 4814 } 4815 break; 4816 case 33: 4817 { 4818 setState(640); 4819 match(CDATA); 4820 } 4821 break; 4822 case 34: 4823 { 4824 setState(641); 4825 match(NEWLINE); 4826 } 4827 break; 4828 case 35: 4829 { 4830 setState(642); 4831 text(); 4832 } 4833 break; 4834 case 36: 4835 { 4836 setState(643); 4837 javadocInlineTag(); 4838 } 4839 break; 4840 } 4841 } 4842 } 4843 setState(648); 4844 _errHandler.sync(this); 4845 _alt = getInterpreter().adaptivePredict(_input,41,_ctx); 4846 } 4847 setState(649); 4848 thTagClose(); 4849 } 4850 } 4851 catch (RecognitionException re) { 4852 _localctx.exception = re; 4853 _errHandler.reportError(this, re); 4854 _errHandler.recover(this, re); 4855 } 4856 finally { 4857 exitRule(); 4858 } 4859 return _localctx; 4860 } 4861 4862 public static class BodyTagOpenContext extends ParserRuleContext { 4863 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4864 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 4865 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4866 public List<AttributeContext> attribute() { 4867 return getRuleContexts(AttributeContext.class); 4868 } 4869 public AttributeContext attribute(int i) { 4870 return getRuleContext(AttributeContext.class,i); 4871 } 4872 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4873 public TerminalNode NEWLINE(int i) { 4874 return getToken(JavadocParser.NEWLINE, i); 4875 } 4876 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4877 public TerminalNode LEADING_ASTERISK(int i) { 4878 return getToken(JavadocParser.LEADING_ASTERISK, i); 4879 } 4880 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4881 public TerminalNode WS(int i) { 4882 return getToken(JavadocParser.WS, i); 4883 } 4884 public BodyTagOpenContext(ParserRuleContext parent, int invokingState) { 4885 super(parent, invokingState); 4886 } 4887 @Override public int getRuleIndex() { return RULE_bodyTagOpen; } 4888 @Override 4889 public void enterRule(ParseTreeListener listener) { 4890 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagOpen(this); 4891 } 4892 @Override 4893 public void exitRule(ParseTreeListener listener) { 4894 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagOpen(this); 4895 } 4896 @Override 4897 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4898 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagOpen(this); 4899 else return visitor.visitChildren(this); 4900 } 4901 } 4902 4903 public final BodyTagOpenContext bodyTagOpen() throws RecognitionException { 4904 BodyTagOpenContext _localctx = new BodyTagOpenContext(_ctx, getState()); 4905 enterRule(_localctx, 42, RULE_bodyTagOpen); 4906 int _la; 4907 try { 4908 enterOuterAlt(_localctx, 1); 4909 { 4910 setState(651); 4911 match(OPEN); 4912 setState(652); 4913 match(BODY_HTML_TAG_NAME); 4914 setState(659); 4915 _errHandler.sync(this); 4916 _la = _input.LA(1); 4917 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 4918 { 4919 setState(657); 4920 switch (_input.LA(1)) { 4921 case HTML_TAG_NAME: 4922 { 4923 setState(653); 4924 attribute(); 4925 } 4926 break; 4927 case NEWLINE: 4928 { 4929 setState(654); 4930 match(NEWLINE); 4931 } 4932 break; 4933 case LEADING_ASTERISK: 4934 { 4935 setState(655); 4936 match(LEADING_ASTERISK); 4937 } 4938 break; 4939 case WS: 4940 { 4941 setState(656); 4942 match(WS); 4943 } 4944 break; 4945 default: 4946 throw new NoViableAltException(this); 4947 } 4948 } 4949 setState(661); 4950 _errHandler.sync(this); 4951 _la = _input.LA(1); 4952 } 4953 setState(662); 4954 match(CLOSE); 4955 } 4956 } 4957 catch (RecognitionException re) { 4958 _localctx.exception = re; 4959 _errHandler.reportError(this, re); 4960 _errHandler.recover(this, re); 4961 } 4962 finally { 4963 exitRule(); 4964 } 4965 return _localctx; 4966 } 4967 4968 public static class BodyTagCloseContext extends ParserRuleContext { 4969 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 4970 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 4971 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 4972 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 4973 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 4974 public TerminalNode NEWLINE(int i) { 4975 return getToken(JavadocParser.NEWLINE, i); 4976 } 4977 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 4978 public TerminalNode LEADING_ASTERISK(int i) { 4979 return getToken(JavadocParser.LEADING_ASTERISK, i); 4980 } 4981 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 4982 public TerminalNode WS(int i) { 4983 return getToken(JavadocParser.WS, i); 4984 } 4985 public BodyTagCloseContext(ParserRuleContext parent, int invokingState) { 4986 super(parent, invokingState); 4987 } 4988 @Override public int getRuleIndex() { return RULE_bodyTagClose; } 4989 @Override 4990 public void enterRule(ParseTreeListener listener) { 4991 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBodyTagClose(this); 4992 } 4993 @Override 4994 public void exitRule(ParseTreeListener listener) { 4995 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBodyTagClose(this); 4996 } 4997 @Override 4998 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 4999 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagClose(this); 5000 else return visitor.visitChildren(this); 5001 } 5002 } 5003 5004 public final BodyTagCloseContext bodyTagClose() throws RecognitionException { 5005 BodyTagCloseContext _localctx = new BodyTagCloseContext(_ctx, getState()); 5006 enterRule(_localctx, 44, RULE_bodyTagClose); 5007 int _la; 5008 try { 5009 enterOuterAlt(_localctx, 1); 5010 { 5011 setState(664); 5012 match(OPEN); 5013 setState(665); 5014 match(SLASH); 5015 setState(666); 5016 match(BODY_HTML_TAG_NAME); 5017 setState(670); 5018 _errHandler.sync(this); 5019 _la = _input.LA(1); 5020 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5021 { 5022 { 5023 setState(667); 5024 _la = _input.LA(1); 5025 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5026 _errHandler.recoverInline(this); 5027 } else { 5028 consume(); 5029 } 5030 } 5031 } 5032 setState(672); 5033 _errHandler.sync(this); 5034 _la = _input.LA(1); 5035 } 5036 setState(673); 5037 match(CLOSE); 5038 } 5039 } 5040 catch (RecognitionException re) { 5041 _localctx.exception = re; 5042 _errHandler.reportError(this, re); 5043 _errHandler.recover(this, re); 5044 } 5045 finally { 5046 exitRule(); 5047 } 5048 return _localctx; 5049 } 5050 5051 public static class BodyContext extends ParserRuleContext { 5052 public BodyTagOpenContext bodyTagOpen() { 5053 return getRuleContext(BodyTagOpenContext.class,0); 5054 } 5055 public BodyTagCloseContext bodyTagClose() { 5056 return getRuleContext(BodyTagCloseContext.class,0); 5057 } 5058 public List<HtmlTagContext> htmlTag() { 5059 return getRuleContexts(HtmlTagContext.class); 5060 } 5061 public HtmlTagContext htmlTag(int i) { 5062 return getRuleContext(HtmlTagContext.class,i); 5063 } 5064 public List<SingletonTagContext> singletonTag() { 5065 return getRuleContexts(SingletonTagContext.class); 5066 } 5067 public SingletonTagContext singletonTag(int i) { 5068 return getRuleContext(SingletonTagContext.class,i); 5069 } 5070 public List<ParagraphContext> paragraph() { 5071 return getRuleContexts(ParagraphContext.class); 5072 } 5073 public ParagraphContext paragraph(int i) { 5074 return getRuleContext(ParagraphContext.class,i); 5075 } 5076 public List<LiContext> li() { 5077 return getRuleContexts(LiContext.class); 5078 } 5079 public LiContext li(int i) { 5080 return getRuleContext(LiContext.class,i); 5081 } 5082 public List<TrContext> tr() { 5083 return getRuleContexts(TrContext.class); 5084 } 5085 public TrContext tr(int i) { 5086 return getRuleContext(TrContext.class,i); 5087 } 5088 public List<TdContext> td() { 5089 return getRuleContexts(TdContext.class); 5090 } 5091 public TdContext td(int i) { 5092 return getRuleContext(TdContext.class,i); 5093 } 5094 public List<ThContext> th() { 5095 return getRuleContexts(ThContext.class); 5096 } 5097 public ThContext th(int i) { 5098 return getRuleContext(ThContext.class,i); 5099 } 5100 public List<ColgroupContext> colgroup() { 5101 return getRuleContexts(ColgroupContext.class); 5102 } 5103 public ColgroupContext colgroup(int i) { 5104 return getRuleContext(ColgroupContext.class,i); 5105 } 5106 public List<DdContext> dd() { 5107 return getRuleContexts(DdContext.class); 5108 } 5109 public DdContext dd(int i) { 5110 return getRuleContext(DdContext.class,i); 5111 } 5112 public List<DtContext> dt() { 5113 return getRuleContexts(DtContext.class); 5114 } 5115 public DtContext dt(int i) { 5116 return getRuleContext(DtContext.class,i); 5117 } 5118 public List<HeadContext> head() { 5119 return getRuleContexts(HeadContext.class); 5120 } 5121 public HeadContext head(int i) { 5122 return getRuleContext(HeadContext.class,i); 5123 } 5124 public List<HtmlContext> html() { 5125 return getRuleContexts(HtmlContext.class); 5126 } 5127 public HtmlContext html(int i) { 5128 return getRuleContext(HtmlContext.class,i); 5129 } 5130 public List<OptionContext> option() { 5131 return getRuleContexts(OptionContext.class); 5132 } 5133 public OptionContext option(int i) { 5134 return getRuleContext(OptionContext.class,i); 5135 } 5136 public List<TbodyContext> tbody() { 5137 return getRuleContexts(TbodyContext.class); 5138 } 5139 public TbodyContext tbody(int i) { 5140 return getRuleContext(TbodyContext.class,i); 5141 } 5142 public List<TheadContext> thead() { 5143 return getRuleContexts(TheadContext.class); 5144 } 5145 public TheadContext thead(int i) { 5146 return getRuleContext(TheadContext.class,i); 5147 } 5148 public List<TfootContext> tfoot() { 5149 return getRuleContexts(TfootContext.class); 5150 } 5151 public TfootContext tfoot(int i) { 5152 return getRuleContext(TfootContext.class,i); 5153 } 5154 public List<PTagOpenContext> pTagOpen() { 5155 return getRuleContexts(PTagOpenContext.class); 5156 } 5157 public PTagOpenContext pTagOpen(int i) { 5158 return getRuleContext(PTagOpenContext.class,i); 5159 } 5160 public List<LiTagOpenContext> liTagOpen() { 5161 return getRuleContexts(LiTagOpenContext.class); 5162 } 5163 public LiTagOpenContext liTagOpen(int i) { 5164 return getRuleContext(LiTagOpenContext.class,i); 5165 } 5166 public List<TrTagOpenContext> trTagOpen() { 5167 return getRuleContexts(TrTagOpenContext.class); 5168 } 5169 public TrTagOpenContext trTagOpen(int i) { 5170 return getRuleContext(TrTagOpenContext.class,i); 5171 } 5172 public List<TdTagOpenContext> tdTagOpen() { 5173 return getRuleContexts(TdTagOpenContext.class); 5174 } 5175 public TdTagOpenContext tdTagOpen(int i) { 5176 return getRuleContext(TdTagOpenContext.class,i); 5177 } 5178 public List<ThTagOpenContext> thTagOpen() { 5179 return getRuleContexts(ThTagOpenContext.class); 5180 } 5181 public ThTagOpenContext thTagOpen(int i) { 5182 return getRuleContext(ThTagOpenContext.class,i); 5183 } 5184 public List<ColgroupTagOpenContext> colgroupTagOpen() { 5185 return getRuleContexts(ColgroupTagOpenContext.class); 5186 } 5187 public ColgroupTagOpenContext colgroupTagOpen(int i) { 5188 return getRuleContext(ColgroupTagOpenContext.class,i); 5189 } 5190 public List<DdTagOpenContext> ddTagOpen() { 5191 return getRuleContexts(DdTagOpenContext.class); 5192 } 5193 public DdTagOpenContext ddTagOpen(int i) { 5194 return getRuleContext(DdTagOpenContext.class,i); 5195 } 5196 public List<DtTagOpenContext> dtTagOpen() { 5197 return getRuleContexts(DtTagOpenContext.class); 5198 } 5199 public DtTagOpenContext dtTagOpen(int i) { 5200 return getRuleContext(DtTagOpenContext.class,i); 5201 } 5202 public List<HeadTagOpenContext> headTagOpen() { 5203 return getRuleContexts(HeadTagOpenContext.class); 5204 } 5205 public HeadTagOpenContext headTagOpen(int i) { 5206 return getRuleContext(HeadTagOpenContext.class,i); 5207 } 5208 public List<HtmlTagOpenContext> htmlTagOpen() { 5209 return getRuleContexts(HtmlTagOpenContext.class); 5210 } 5211 public HtmlTagOpenContext htmlTagOpen(int i) { 5212 return getRuleContext(HtmlTagOpenContext.class,i); 5213 } 5214 public List<OptionTagOpenContext> optionTagOpen() { 5215 return getRuleContexts(OptionTagOpenContext.class); 5216 } 5217 public OptionTagOpenContext optionTagOpen(int i) { 5218 return getRuleContext(OptionTagOpenContext.class,i); 5219 } 5220 public List<TbodyTagOpenContext> tbodyTagOpen() { 5221 return getRuleContexts(TbodyTagOpenContext.class); 5222 } 5223 public TbodyTagOpenContext tbodyTagOpen(int i) { 5224 return getRuleContext(TbodyTagOpenContext.class,i); 5225 } 5226 public List<TheadTagOpenContext> theadTagOpen() { 5227 return getRuleContexts(TheadTagOpenContext.class); 5228 } 5229 public TheadTagOpenContext theadTagOpen(int i) { 5230 return getRuleContext(TheadTagOpenContext.class,i); 5231 } 5232 public List<TfootTagOpenContext> tfootTagOpen() { 5233 return getRuleContexts(TfootTagOpenContext.class); 5234 } 5235 public TfootTagOpenContext tfootTagOpen(int i) { 5236 return getRuleContext(TfootTagOpenContext.class,i); 5237 } 5238 public List<HtmlCommentContext> htmlComment() { 5239 return getRuleContexts(HtmlCommentContext.class); 5240 } 5241 public HtmlCommentContext htmlComment(int i) { 5242 return getRuleContext(HtmlCommentContext.class,i); 5243 } 5244 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5245 public TerminalNode CDATA(int i) { 5246 return getToken(JavadocParser.CDATA, i); 5247 } 5248 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5249 public TerminalNode NEWLINE(int i) { 5250 return getToken(JavadocParser.NEWLINE, i); 5251 } 5252 public List<TextContext> text() { 5253 return getRuleContexts(TextContext.class); 5254 } 5255 public TextContext text(int i) { 5256 return getRuleContext(TextContext.class,i); 5257 } 5258 public List<JavadocInlineTagContext> javadocInlineTag() { 5259 return getRuleContexts(JavadocInlineTagContext.class); 5260 } 5261 public JavadocInlineTagContext javadocInlineTag(int i) { 5262 return getRuleContext(JavadocInlineTagContext.class,i); 5263 } 5264 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5265 public TerminalNode LEADING_ASTERISK(int i) { 5266 return getToken(JavadocParser.LEADING_ASTERISK, i); 5267 } 5268 public BodyContext(ParserRuleContext parent, int invokingState) { 5269 super(parent, invokingState); 5270 } 5271 @Override public int getRuleIndex() { return RULE_body; } 5272 @Override 5273 public void enterRule(ParseTreeListener listener) { 5274 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBody(this); 5275 } 5276 @Override 5277 public void exitRule(ParseTreeListener listener) { 5278 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBody(this); 5279 } 5280 @Override 5281 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5282 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBody(this); 5283 else return visitor.visitChildren(this); 5284 } 5285 } 5286 5287 public final BodyContext body() throws RecognitionException { 5288 BodyContext _localctx = new BodyContext(_ctx, getState()); 5289 enterRule(_localctx, 46, RULE_body); 5290 try { 5291 int _alt; 5292 enterOuterAlt(_localctx, 1); 5293 { 5294 setState(675); 5295 bodyTagOpen(); 5296 setState(715); 5297 _errHandler.sync(this); 5298 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5299 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5300 if ( _alt==1 ) { 5301 { 5302 setState(713); 5303 _errHandler.sync(this); 5304 switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) { 5305 case 1: 5306 { 5307 setState(676); 5308 htmlTag(); 5309 } 5310 break; 5311 case 2: 5312 { 5313 setState(677); 5314 singletonTag(); 5315 } 5316 break; 5317 case 3: 5318 { 5319 setState(678); 5320 paragraph(); 5321 } 5322 break; 5323 case 4: 5324 { 5325 setState(679); 5326 li(); 5327 } 5328 break; 5329 case 5: 5330 { 5331 setState(680); 5332 tr(); 5333 } 5334 break; 5335 case 6: 5336 { 5337 setState(681); 5338 td(); 5339 } 5340 break; 5341 case 7: 5342 { 5343 setState(682); 5344 th(); 5345 } 5346 break; 5347 case 8: 5348 { 5349 setState(683); 5350 colgroup(); 5351 } 5352 break; 5353 case 9: 5354 { 5355 setState(684); 5356 dd(); 5357 } 5358 break; 5359 case 10: 5360 { 5361 setState(685); 5362 dt(); 5363 } 5364 break; 5365 case 11: 5366 { 5367 setState(686); 5368 head(); 5369 } 5370 break; 5371 case 12: 5372 { 5373 setState(687); 5374 html(); 5375 } 5376 break; 5377 case 13: 5378 { 5379 setState(688); 5380 option(); 5381 } 5382 break; 5383 case 14: 5384 { 5385 setState(689); 5386 tbody(); 5387 } 5388 break; 5389 case 15: 5390 { 5391 setState(690); 5392 thead(); 5393 } 5394 break; 5395 case 16: 5396 { 5397 setState(691); 5398 tfoot(); 5399 } 5400 break; 5401 case 17: 5402 { 5403 setState(692); 5404 pTagOpen(); 5405 } 5406 break; 5407 case 18: 5408 { 5409 setState(693); 5410 liTagOpen(); 5411 } 5412 break; 5413 case 19: 5414 { 5415 setState(694); 5416 trTagOpen(); 5417 } 5418 break; 5419 case 20: 5420 { 5421 setState(695); 5422 tdTagOpen(); 5423 } 5424 break; 5425 case 21: 5426 { 5427 setState(696); 5428 thTagOpen(); 5429 } 5430 break; 5431 case 22: 5432 { 5433 setState(697); 5434 colgroupTagOpen(); 5435 } 5436 break; 5437 case 23: 5438 { 5439 setState(698); 5440 ddTagOpen(); 5441 } 5442 break; 5443 case 24: 5444 { 5445 setState(699); 5446 dtTagOpen(); 5447 } 5448 break; 5449 case 25: 5450 { 5451 setState(700); 5452 headTagOpen(); 5453 } 5454 break; 5455 case 26: 5456 { 5457 setState(701); 5458 htmlTagOpen(); 5459 } 5460 break; 5461 case 27: 5462 { 5463 setState(702); 5464 optionTagOpen(); 5465 } 5466 break; 5467 case 28: 5468 { 5469 setState(703); 5470 tbodyTagOpen(); 5471 } 5472 break; 5473 case 29: 5474 { 5475 setState(704); 5476 theadTagOpen(); 5477 } 5478 break; 5479 case 30: 5480 { 5481 setState(705); 5482 tfootTagOpen(); 5483 } 5484 break; 5485 case 31: 5486 { 5487 { 5488 setState(706); 5489 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 5490 setState(707); 5491 match(LEADING_ASTERISK); 5492 } 5493 } 5494 break; 5495 case 32: 5496 { 5497 setState(708); 5498 htmlComment(); 5499 } 5500 break; 5501 case 33: 5502 { 5503 setState(709); 5504 match(CDATA); 5505 } 5506 break; 5507 case 34: 5508 { 5509 setState(710); 5510 match(NEWLINE); 5511 } 5512 break; 5513 case 35: 5514 { 5515 setState(711); 5516 text(); 5517 } 5518 break; 5519 case 36: 5520 { 5521 setState(712); 5522 javadocInlineTag(); 5523 } 5524 break; 5525 } 5526 } 5527 } 5528 setState(717); 5529 _errHandler.sync(this); 5530 _alt = getInterpreter().adaptivePredict(_input,46,_ctx); 5531 } 5532 setState(718); 5533 bodyTagClose(); 5534 } 5535 } 5536 catch (RecognitionException re) { 5537 _localctx.exception = re; 5538 _errHandler.reportError(this, re); 5539 _errHandler.recover(this, re); 5540 } 5541 finally { 5542 exitRule(); 5543 } 5544 return _localctx; 5545 } 5546 5547 public static class ColgroupTagOpenContext extends ParserRuleContext { 5548 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5549 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5550 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5551 public List<AttributeContext> attribute() { 5552 return getRuleContexts(AttributeContext.class); 5553 } 5554 public AttributeContext attribute(int i) { 5555 return getRuleContext(AttributeContext.class,i); 5556 } 5557 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5558 public TerminalNode NEWLINE(int i) { 5559 return getToken(JavadocParser.NEWLINE, i); 5560 } 5561 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5562 public TerminalNode LEADING_ASTERISK(int i) { 5563 return getToken(JavadocParser.LEADING_ASTERISK, i); 5564 } 5565 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5566 public TerminalNode WS(int i) { 5567 return getToken(JavadocParser.WS, i); 5568 } 5569 public ColgroupTagOpenContext(ParserRuleContext parent, int invokingState) { 5570 super(parent, invokingState); 5571 } 5572 @Override public int getRuleIndex() { return RULE_colgroupTagOpen; } 5573 @Override 5574 public void enterRule(ParseTreeListener listener) { 5575 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagOpen(this); 5576 } 5577 @Override 5578 public void exitRule(ParseTreeListener listener) { 5579 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagOpen(this); 5580 } 5581 @Override 5582 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5583 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagOpen(this); 5584 else return visitor.visitChildren(this); 5585 } 5586 } 5587 5588 public final ColgroupTagOpenContext colgroupTagOpen() throws RecognitionException { 5589 ColgroupTagOpenContext _localctx = new ColgroupTagOpenContext(_ctx, getState()); 5590 enterRule(_localctx, 48, RULE_colgroupTagOpen); 5591 int _la; 5592 try { 5593 enterOuterAlt(_localctx, 1); 5594 { 5595 setState(720); 5596 match(OPEN); 5597 setState(721); 5598 match(COLGROUP_HTML_TAG_NAME); 5599 setState(728); 5600 _errHandler.sync(this); 5601 _la = _input.LA(1); 5602 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 5603 { 5604 setState(726); 5605 switch (_input.LA(1)) { 5606 case HTML_TAG_NAME: 5607 { 5608 setState(722); 5609 attribute(); 5610 } 5611 break; 5612 case NEWLINE: 5613 { 5614 setState(723); 5615 match(NEWLINE); 5616 } 5617 break; 5618 case LEADING_ASTERISK: 5619 { 5620 setState(724); 5621 match(LEADING_ASTERISK); 5622 } 5623 break; 5624 case WS: 5625 { 5626 setState(725); 5627 match(WS); 5628 } 5629 break; 5630 default: 5631 throw new NoViableAltException(this); 5632 } 5633 } 5634 setState(730); 5635 _errHandler.sync(this); 5636 _la = _input.LA(1); 5637 } 5638 setState(731); 5639 match(CLOSE); 5640 } 5641 } 5642 catch (RecognitionException re) { 5643 _localctx.exception = re; 5644 _errHandler.reportError(this, re); 5645 _errHandler.recover(this, re); 5646 } 5647 finally { 5648 exitRule(); 5649 } 5650 return _localctx; 5651 } 5652 5653 public static class ColgroupTagCloseContext extends ParserRuleContext { 5654 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 5655 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 5656 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 5657 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 5658 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5659 public TerminalNode NEWLINE(int i) { 5660 return getToken(JavadocParser.NEWLINE, i); 5661 } 5662 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5663 public TerminalNode LEADING_ASTERISK(int i) { 5664 return getToken(JavadocParser.LEADING_ASTERISK, i); 5665 } 5666 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 5667 public TerminalNode WS(int i) { 5668 return getToken(JavadocParser.WS, i); 5669 } 5670 public ColgroupTagCloseContext(ParserRuleContext parent, int invokingState) { 5671 super(parent, invokingState); 5672 } 5673 @Override public int getRuleIndex() { return RULE_colgroupTagClose; } 5674 @Override 5675 public void enterRule(ParseTreeListener listener) { 5676 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroupTagClose(this); 5677 } 5678 @Override 5679 public void exitRule(ParseTreeListener listener) { 5680 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroupTagClose(this); 5681 } 5682 @Override 5683 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5684 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagClose(this); 5685 else return visitor.visitChildren(this); 5686 } 5687 } 5688 5689 public final ColgroupTagCloseContext colgroupTagClose() throws RecognitionException { 5690 ColgroupTagCloseContext _localctx = new ColgroupTagCloseContext(_ctx, getState()); 5691 enterRule(_localctx, 50, RULE_colgroupTagClose); 5692 int _la; 5693 try { 5694 enterOuterAlt(_localctx, 1); 5695 { 5696 setState(733); 5697 match(OPEN); 5698 setState(734); 5699 match(SLASH); 5700 setState(735); 5701 match(COLGROUP_HTML_TAG_NAME); 5702 setState(739); 5703 _errHandler.sync(this); 5704 _la = _input.LA(1); 5705 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 5706 { 5707 { 5708 setState(736); 5709 _la = _input.LA(1); 5710 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 5711 _errHandler.recoverInline(this); 5712 } else { 5713 consume(); 5714 } 5715 } 5716 } 5717 setState(741); 5718 _errHandler.sync(this); 5719 _la = _input.LA(1); 5720 } 5721 setState(742); 5722 match(CLOSE); 5723 } 5724 } 5725 catch (RecognitionException re) { 5726 _localctx.exception = re; 5727 _errHandler.reportError(this, re); 5728 _errHandler.recover(this, re); 5729 } 5730 finally { 5731 exitRule(); 5732 } 5733 return _localctx; 5734 } 5735 5736 public static class ColgroupContext extends ParserRuleContext { 5737 public ColgroupTagOpenContext colgroupTagOpen() { 5738 return getRuleContext(ColgroupTagOpenContext.class,0); 5739 } 5740 public ColgroupTagCloseContext colgroupTagClose() { 5741 return getRuleContext(ColgroupTagCloseContext.class,0); 5742 } 5743 public List<HtmlTagContext> htmlTag() { 5744 return getRuleContexts(HtmlTagContext.class); 5745 } 5746 public HtmlTagContext htmlTag(int i) { 5747 return getRuleContext(HtmlTagContext.class,i); 5748 } 5749 public List<SingletonTagContext> singletonTag() { 5750 return getRuleContexts(SingletonTagContext.class); 5751 } 5752 public SingletonTagContext singletonTag(int i) { 5753 return getRuleContext(SingletonTagContext.class,i); 5754 } 5755 public List<ParagraphContext> paragraph() { 5756 return getRuleContexts(ParagraphContext.class); 5757 } 5758 public ParagraphContext paragraph(int i) { 5759 return getRuleContext(ParagraphContext.class,i); 5760 } 5761 public List<LiContext> li() { 5762 return getRuleContexts(LiContext.class); 5763 } 5764 public LiContext li(int i) { 5765 return getRuleContext(LiContext.class,i); 5766 } 5767 public List<TrContext> tr() { 5768 return getRuleContexts(TrContext.class); 5769 } 5770 public TrContext tr(int i) { 5771 return getRuleContext(TrContext.class,i); 5772 } 5773 public List<TdContext> td() { 5774 return getRuleContexts(TdContext.class); 5775 } 5776 public TdContext td(int i) { 5777 return getRuleContext(TdContext.class,i); 5778 } 5779 public List<ThContext> th() { 5780 return getRuleContexts(ThContext.class); 5781 } 5782 public ThContext th(int i) { 5783 return getRuleContext(ThContext.class,i); 5784 } 5785 public List<BodyContext> body() { 5786 return getRuleContexts(BodyContext.class); 5787 } 5788 public BodyContext body(int i) { 5789 return getRuleContext(BodyContext.class,i); 5790 } 5791 public List<DdContext> dd() { 5792 return getRuleContexts(DdContext.class); 5793 } 5794 public DdContext dd(int i) { 5795 return getRuleContext(DdContext.class,i); 5796 } 5797 public List<DtContext> dt() { 5798 return getRuleContexts(DtContext.class); 5799 } 5800 public DtContext dt(int i) { 5801 return getRuleContext(DtContext.class,i); 5802 } 5803 public List<HeadContext> head() { 5804 return getRuleContexts(HeadContext.class); 5805 } 5806 public HeadContext head(int i) { 5807 return getRuleContext(HeadContext.class,i); 5808 } 5809 public List<HtmlContext> html() { 5810 return getRuleContexts(HtmlContext.class); 5811 } 5812 public HtmlContext html(int i) { 5813 return getRuleContext(HtmlContext.class,i); 5814 } 5815 public List<OptionContext> option() { 5816 return getRuleContexts(OptionContext.class); 5817 } 5818 public OptionContext option(int i) { 5819 return getRuleContext(OptionContext.class,i); 5820 } 5821 public List<TbodyContext> tbody() { 5822 return getRuleContexts(TbodyContext.class); 5823 } 5824 public TbodyContext tbody(int i) { 5825 return getRuleContext(TbodyContext.class,i); 5826 } 5827 public List<TheadContext> thead() { 5828 return getRuleContexts(TheadContext.class); 5829 } 5830 public TheadContext thead(int i) { 5831 return getRuleContext(TheadContext.class,i); 5832 } 5833 public List<TfootContext> tfoot() { 5834 return getRuleContexts(TfootContext.class); 5835 } 5836 public TfootContext tfoot(int i) { 5837 return getRuleContext(TfootContext.class,i); 5838 } 5839 public List<PTagOpenContext> pTagOpen() { 5840 return getRuleContexts(PTagOpenContext.class); 5841 } 5842 public PTagOpenContext pTagOpen(int i) { 5843 return getRuleContext(PTagOpenContext.class,i); 5844 } 5845 public List<LiTagOpenContext> liTagOpen() { 5846 return getRuleContexts(LiTagOpenContext.class); 5847 } 5848 public LiTagOpenContext liTagOpen(int i) { 5849 return getRuleContext(LiTagOpenContext.class,i); 5850 } 5851 public List<TrTagOpenContext> trTagOpen() { 5852 return getRuleContexts(TrTagOpenContext.class); 5853 } 5854 public TrTagOpenContext trTagOpen(int i) { 5855 return getRuleContext(TrTagOpenContext.class,i); 5856 } 5857 public List<TdTagOpenContext> tdTagOpen() { 5858 return getRuleContexts(TdTagOpenContext.class); 5859 } 5860 public TdTagOpenContext tdTagOpen(int i) { 5861 return getRuleContext(TdTagOpenContext.class,i); 5862 } 5863 public List<ThTagOpenContext> thTagOpen() { 5864 return getRuleContexts(ThTagOpenContext.class); 5865 } 5866 public ThTagOpenContext thTagOpen(int i) { 5867 return getRuleContext(ThTagOpenContext.class,i); 5868 } 5869 public List<BodyTagOpenContext> bodyTagOpen() { 5870 return getRuleContexts(BodyTagOpenContext.class); 5871 } 5872 public BodyTagOpenContext bodyTagOpen(int i) { 5873 return getRuleContext(BodyTagOpenContext.class,i); 5874 } 5875 public List<DdTagOpenContext> ddTagOpen() { 5876 return getRuleContexts(DdTagOpenContext.class); 5877 } 5878 public DdTagOpenContext ddTagOpen(int i) { 5879 return getRuleContext(DdTagOpenContext.class,i); 5880 } 5881 public List<DtTagOpenContext> dtTagOpen() { 5882 return getRuleContexts(DtTagOpenContext.class); 5883 } 5884 public DtTagOpenContext dtTagOpen(int i) { 5885 return getRuleContext(DtTagOpenContext.class,i); 5886 } 5887 public List<HeadTagOpenContext> headTagOpen() { 5888 return getRuleContexts(HeadTagOpenContext.class); 5889 } 5890 public HeadTagOpenContext headTagOpen(int i) { 5891 return getRuleContext(HeadTagOpenContext.class,i); 5892 } 5893 public List<HtmlTagOpenContext> htmlTagOpen() { 5894 return getRuleContexts(HtmlTagOpenContext.class); 5895 } 5896 public HtmlTagOpenContext htmlTagOpen(int i) { 5897 return getRuleContext(HtmlTagOpenContext.class,i); 5898 } 5899 public List<OptionTagOpenContext> optionTagOpen() { 5900 return getRuleContexts(OptionTagOpenContext.class); 5901 } 5902 public OptionTagOpenContext optionTagOpen(int i) { 5903 return getRuleContext(OptionTagOpenContext.class,i); 5904 } 5905 public List<TbodyTagOpenContext> tbodyTagOpen() { 5906 return getRuleContexts(TbodyTagOpenContext.class); 5907 } 5908 public TbodyTagOpenContext tbodyTagOpen(int i) { 5909 return getRuleContext(TbodyTagOpenContext.class,i); 5910 } 5911 public List<TheadTagOpenContext> theadTagOpen() { 5912 return getRuleContexts(TheadTagOpenContext.class); 5913 } 5914 public TheadTagOpenContext theadTagOpen(int i) { 5915 return getRuleContext(TheadTagOpenContext.class,i); 5916 } 5917 public List<TfootTagOpenContext> tfootTagOpen() { 5918 return getRuleContexts(TfootTagOpenContext.class); 5919 } 5920 public TfootTagOpenContext tfootTagOpen(int i) { 5921 return getRuleContext(TfootTagOpenContext.class,i); 5922 } 5923 public List<HtmlCommentContext> htmlComment() { 5924 return getRuleContexts(HtmlCommentContext.class); 5925 } 5926 public HtmlCommentContext htmlComment(int i) { 5927 return getRuleContext(HtmlCommentContext.class,i); 5928 } 5929 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 5930 public TerminalNode CDATA(int i) { 5931 return getToken(JavadocParser.CDATA, i); 5932 } 5933 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 5934 public TerminalNode NEWLINE(int i) { 5935 return getToken(JavadocParser.NEWLINE, i); 5936 } 5937 public List<TextContext> text() { 5938 return getRuleContexts(TextContext.class); 5939 } 5940 public TextContext text(int i) { 5941 return getRuleContext(TextContext.class,i); 5942 } 5943 public List<JavadocInlineTagContext> javadocInlineTag() { 5944 return getRuleContexts(JavadocInlineTagContext.class); 5945 } 5946 public JavadocInlineTagContext javadocInlineTag(int i) { 5947 return getRuleContext(JavadocInlineTagContext.class,i); 5948 } 5949 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 5950 public TerminalNode LEADING_ASTERISK(int i) { 5951 return getToken(JavadocParser.LEADING_ASTERISK, i); 5952 } 5953 public ColgroupContext(ParserRuleContext parent, int invokingState) { 5954 super(parent, invokingState); 5955 } 5956 @Override public int getRuleIndex() { return RULE_colgroup; } 5957 @Override 5958 public void enterRule(ParseTreeListener listener) { 5959 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColgroup(this); 5960 } 5961 @Override 5962 public void exitRule(ParseTreeListener listener) { 5963 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColgroup(this); 5964 } 5965 @Override 5966 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 5967 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroup(this); 5968 else return visitor.visitChildren(this); 5969 } 5970 } 5971 5972 public final ColgroupContext colgroup() throws RecognitionException { 5973 ColgroupContext _localctx = new ColgroupContext(_ctx, getState()); 5974 enterRule(_localctx, 52, RULE_colgroup); 5975 try { 5976 int _alt; 5977 enterOuterAlt(_localctx, 1); 5978 { 5979 setState(744); 5980 colgroupTagOpen(); 5981 setState(784); 5982 _errHandler.sync(this); 5983 _alt = getInterpreter().adaptivePredict(_input,51,_ctx); 5984 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 5985 if ( _alt==1 ) { 5986 { 5987 setState(782); 5988 _errHandler.sync(this); 5989 switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { 5990 case 1: 5991 { 5992 setState(745); 5993 htmlTag(); 5994 } 5995 break; 5996 case 2: 5997 { 5998 setState(746); 5999 singletonTag(); 6000 } 6001 break; 6002 case 3: 6003 { 6004 setState(747); 6005 paragraph(); 6006 } 6007 break; 6008 case 4: 6009 { 6010 setState(748); 6011 li(); 6012 } 6013 break; 6014 case 5: 6015 { 6016 setState(749); 6017 tr(); 6018 } 6019 break; 6020 case 6: 6021 { 6022 setState(750); 6023 td(); 6024 } 6025 break; 6026 case 7: 6027 { 6028 setState(751); 6029 th(); 6030 } 6031 break; 6032 case 8: 6033 { 6034 setState(752); 6035 body(); 6036 } 6037 break; 6038 case 9: 6039 { 6040 setState(753); 6041 dd(); 6042 } 6043 break; 6044 case 10: 6045 { 6046 setState(754); 6047 dt(); 6048 } 6049 break; 6050 case 11: 6051 { 6052 setState(755); 6053 head(); 6054 } 6055 break; 6056 case 12: 6057 { 6058 setState(756); 6059 html(); 6060 } 6061 break; 6062 case 13: 6063 { 6064 setState(757); 6065 option(); 6066 } 6067 break; 6068 case 14: 6069 { 6070 setState(758); 6071 tbody(); 6072 } 6073 break; 6074 case 15: 6075 { 6076 setState(759); 6077 thead(); 6078 } 6079 break; 6080 case 16: 6081 { 6082 setState(760); 6083 tfoot(); 6084 } 6085 break; 6086 case 17: 6087 { 6088 setState(761); 6089 pTagOpen(); 6090 } 6091 break; 6092 case 18: 6093 { 6094 setState(762); 6095 liTagOpen(); 6096 } 6097 break; 6098 case 19: 6099 { 6100 setState(763); 6101 trTagOpen(); 6102 } 6103 break; 6104 case 20: 6105 { 6106 setState(764); 6107 tdTagOpen(); 6108 } 6109 break; 6110 case 21: 6111 { 6112 setState(765); 6113 thTagOpen(); 6114 } 6115 break; 6116 case 22: 6117 { 6118 setState(766); 6119 bodyTagOpen(); 6120 } 6121 break; 6122 case 23: 6123 { 6124 setState(767); 6125 ddTagOpen(); 6126 } 6127 break; 6128 case 24: 6129 { 6130 setState(768); 6131 dtTagOpen(); 6132 } 6133 break; 6134 case 25: 6135 { 6136 setState(769); 6137 headTagOpen(); 6138 } 6139 break; 6140 case 26: 6141 { 6142 setState(770); 6143 htmlTagOpen(); 6144 } 6145 break; 6146 case 27: 6147 { 6148 setState(771); 6149 optionTagOpen(); 6150 } 6151 break; 6152 case 28: 6153 { 6154 setState(772); 6155 tbodyTagOpen(); 6156 } 6157 break; 6158 case 29: 6159 { 6160 setState(773); 6161 theadTagOpen(); 6162 } 6163 break; 6164 case 30: 6165 { 6166 setState(774); 6167 tfootTagOpen(); 6168 } 6169 break; 6170 case 31: 6171 { 6172 { 6173 setState(775); 6174 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6175 setState(776); 6176 match(LEADING_ASTERISK); 6177 } 6178 } 6179 break; 6180 case 32: 6181 { 6182 setState(777); 6183 htmlComment(); 6184 } 6185 break; 6186 case 33: 6187 { 6188 setState(778); 6189 match(CDATA); 6190 } 6191 break; 6192 case 34: 6193 { 6194 setState(779); 6195 match(NEWLINE); 6196 } 6197 break; 6198 case 35: 6199 { 6200 setState(780); 6201 text(); 6202 } 6203 break; 6204 case 36: 6205 { 6206 setState(781); 6207 javadocInlineTag(); 6208 } 6209 break; 6210 } 6211 } 6212 } 6213 setState(786); 6214 _errHandler.sync(this); 6215 _alt = getInterpreter().adaptivePredict(_input,51,_ctx); 6216 } 6217 setState(787); 6218 colgroupTagClose(); 6219 } 6220 } 6221 catch (RecognitionException re) { 6222 _localctx.exception = re; 6223 _errHandler.reportError(this, re); 6224 _errHandler.recover(this, re); 6225 } 6226 finally { 6227 exitRule(); 6228 } 6229 return _localctx; 6230 } 6231 6232 public static class DdTagOpenContext extends ParserRuleContext { 6233 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6234 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6235 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6236 public List<AttributeContext> attribute() { 6237 return getRuleContexts(AttributeContext.class); 6238 } 6239 public AttributeContext attribute(int i) { 6240 return getRuleContext(AttributeContext.class,i); 6241 } 6242 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6243 public TerminalNode NEWLINE(int i) { 6244 return getToken(JavadocParser.NEWLINE, i); 6245 } 6246 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6247 public TerminalNode LEADING_ASTERISK(int i) { 6248 return getToken(JavadocParser.LEADING_ASTERISK, i); 6249 } 6250 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6251 public TerminalNode WS(int i) { 6252 return getToken(JavadocParser.WS, i); 6253 } 6254 public DdTagOpenContext(ParserRuleContext parent, int invokingState) { 6255 super(parent, invokingState); 6256 } 6257 @Override public int getRuleIndex() { return RULE_ddTagOpen; } 6258 @Override 6259 public void enterRule(ParseTreeListener listener) { 6260 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagOpen(this); 6261 } 6262 @Override 6263 public void exitRule(ParseTreeListener listener) { 6264 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagOpen(this); 6265 } 6266 @Override 6267 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6268 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagOpen(this); 6269 else return visitor.visitChildren(this); 6270 } 6271 } 6272 6273 public final DdTagOpenContext ddTagOpen() throws RecognitionException { 6274 DdTagOpenContext _localctx = new DdTagOpenContext(_ctx, getState()); 6275 enterRule(_localctx, 54, RULE_ddTagOpen); 6276 int _la; 6277 try { 6278 enterOuterAlt(_localctx, 1); 6279 { 6280 setState(789); 6281 match(OPEN); 6282 setState(790); 6283 match(DD_HTML_TAG_NAME); 6284 setState(797); 6285 _errHandler.sync(this); 6286 _la = _input.LA(1); 6287 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6288 { 6289 setState(795); 6290 switch (_input.LA(1)) { 6291 case HTML_TAG_NAME: 6292 { 6293 setState(791); 6294 attribute(); 6295 } 6296 break; 6297 case NEWLINE: 6298 { 6299 setState(792); 6300 match(NEWLINE); 6301 } 6302 break; 6303 case LEADING_ASTERISK: 6304 { 6305 setState(793); 6306 match(LEADING_ASTERISK); 6307 } 6308 break; 6309 case WS: 6310 { 6311 setState(794); 6312 match(WS); 6313 } 6314 break; 6315 default: 6316 throw new NoViableAltException(this); 6317 } 6318 } 6319 setState(799); 6320 _errHandler.sync(this); 6321 _la = _input.LA(1); 6322 } 6323 setState(800); 6324 match(CLOSE); 6325 } 6326 } 6327 catch (RecognitionException re) { 6328 _localctx.exception = re; 6329 _errHandler.reportError(this, re); 6330 _errHandler.recover(this, re); 6331 } 6332 finally { 6333 exitRule(); 6334 } 6335 return _localctx; 6336 } 6337 6338 public static class DdTagCloseContext extends ParserRuleContext { 6339 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6340 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 6341 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 6342 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6343 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6344 public TerminalNode NEWLINE(int i) { 6345 return getToken(JavadocParser.NEWLINE, i); 6346 } 6347 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6348 public TerminalNode LEADING_ASTERISK(int i) { 6349 return getToken(JavadocParser.LEADING_ASTERISK, i); 6350 } 6351 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6352 public TerminalNode WS(int i) { 6353 return getToken(JavadocParser.WS, i); 6354 } 6355 public DdTagCloseContext(ParserRuleContext parent, int invokingState) { 6356 super(parent, invokingState); 6357 } 6358 @Override public int getRuleIndex() { return RULE_ddTagClose; } 6359 @Override 6360 public void enterRule(ParseTreeListener listener) { 6361 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDdTagClose(this); 6362 } 6363 @Override 6364 public void exitRule(ParseTreeListener listener) { 6365 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDdTagClose(this); 6366 } 6367 @Override 6368 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6369 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagClose(this); 6370 else return visitor.visitChildren(this); 6371 } 6372 } 6373 6374 public final DdTagCloseContext ddTagClose() throws RecognitionException { 6375 DdTagCloseContext _localctx = new DdTagCloseContext(_ctx, getState()); 6376 enterRule(_localctx, 56, RULE_ddTagClose); 6377 int _la; 6378 try { 6379 enterOuterAlt(_localctx, 1); 6380 { 6381 setState(802); 6382 match(OPEN); 6383 setState(803); 6384 match(SLASH); 6385 setState(804); 6386 match(DD_HTML_TAG_NAME); 6387 setState(808); 6388 _errHandler.sync(this); 6389 _la = _input.LA(1); 6390 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 6391 { 6392 { 6393 setState(805); 6394 _la = _input.LA(1); 6395 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 6396 _errHandler.recoverInline(this); 6397 } else { 6398 consume(); 6399 } 6400 } 6401 } 6402 setState(810); 6403 _errHandler.sync(this); 6404 _la = _input.LA(1); 6405 } 6406 setState(811); 6407 match(CLOSE); 6408 } 6409 } 6410 catch (RecognitionException re) { 6411 _localctx.exception = re; 6412 _errHandler.reportError(this, re); 6413 _errHandler.recover(this, re); 6414 } 6415 finally { 6416 exitRule(); 6417 } 6418 return _localctx; 6419 } 6420 6421 public static class DdContext extends ParserRuleContext { 6422 public DdTagOpenContext ddTagOpen() { 6423 return getRuleContext(DdTagOpenContext.class,0); 6424 } 6425 public DdTagCloseContext ddTagClose() { 6426 return getRuleContext(DdTagCloseContext.class,0); 6427 } 6428 public List<HtmlTagContext> htmlTag() { 6429 return getRuleContexts(HtmlTagContext.class); 6430 } 6431 public HtmlTagContext htmlTag(int i) { 6432 return getRuleContext(HtmlTagContext.class,i); 6433 } 6434 public List<SingletonTagContext> singletonTag() { 6435 return getRuleContexts(SingletonTagContext.class); 6436 } 6437 public SingletonTagContext singletonTag(int i) { 6438 return getRuleContext(SingletonTagContext.class,i); 6439 } 6440 public List<ParagraphContext> paragraph() { 6441 return getRuleContexts(ParagraphContext.class); 6442 } 6443 public ParagraphContext paragraph(int i) { 6444 return getRuleContext(ParagraphContext.class,i); 6445 } 6446 public List<LiContext> li() { 6447 return getRuleContexts(LiContext.class); 6448 } 6449 public LiContext li(int i) { 6450 return getRuleContext(LiContext.class,i); 6451 } 6452 public List<TrContext> tr() { 6453 return getRuleContexts(TrContext.class); 6454 } 6455 public TrContext tr(int i) { 6456 return getRuleContext(TrContext.class,i); 6457 } 6458 public List<TdContext> td() { 6459 return getRuleContexts(TdContext.class); 6460 } 6461 public TdContext td(int i) { 6462 return getRuleContext(TdContext.class,i); 6463 } 6464 public List<ThContext> th() { 6465 return getRuleContexts(ThContext.class); 6466 } 6467 public ThContext th(int i) { 6468 return getRuleContext(ThContext.class,i); 6469 } 6470 public List<BodyContext> body() { 6471 return getRuleContexts(BodyContext.class); 6472 } 6473 public BodyContext body(int i) { 6474 return getRuleContext(BodyContext.class,i); 6475 } 6476 public List<ColgroupContext> colgroup() { 6477 return getRuleContexts(ColgroupContext.class); 6478 } 6479 public ColgroupContext colgroup(int i) { 6480 return getRuleContext(ColgroupContext.class,i); 6481 } 6482 public List<DtContext> dt() { 6483 return getRuleContexts(DtContext.class); 6484 } 6485 public DtContext dt(int i) { 6486 return getRuleContext(DtContext.class,i); 6487 } 6488 public List<HeadContext> head() { 6489 return getRuleContexts(HeadContext.class); 6490 } 6491 public HeadContext head(int i) { 6492 return getRuleContext(HeadContext.class,i); 6493 } 6494 public List<HtmlContext> html() { 6495 return getRuleContexts(HtmlContext.class); 6496 } 6497 public HtmlContext html(int i) { 6498 return getRuleContext(HtmlContext.class,i); 6499 } 6500 public List<OptionContext> option() { 6501 return getRuleContexts(OptionContext.class); 6502 } 6503 public OptionContext option(int i) { 6504 return getRuleContext(OptionContext.class,i); 6505 } 6506 public List<TbodyContext> tbody() { 6507 return getRuleContexts(TbodyContext.class); 6508 } 6509 public TbodyContext tbody(int i) { 6510 return getRuleContext(TbodyContext.class,i); 6511 } 6512 public List<TheadContext> thead() { 6513 return getRuleContexts(TheadContext.class); 6514 } 6515 public TheadContext thead(int i) { 6516 return getRuleContext(TheadContext.class,i); 6517 } 6518 public List<TfootContext> tfoot() { 6519 return getRuleContexts(TfootContext.class); 6520 } 6521 public TfootContext tfoot(int i) { 6522 return getRuleContext(TfootContext.class,i); 6523 } 6524 public List<PTagOpenContext> pTagOpen() { 6525 return getRuleContexts(PTagOpenContext.class); 6526 } 6527 public PTagOpenContext pTagOpen(int i) { 6528 return getRuleContext(PTagOpenContext.class,i); 6529 } 6530 public List<LiTagOpenContext> liTagOpen() { 6531 return getRuleContexts(LiTagOpenContext.class); 6532 } 6533 public LiTagOpenContext liTagOpen(int i) { 6534 return getRuleContext(LiTagOpenContext.class,i); 6535 } 6536 public List<TrTagOpenContext> trTagOpen() { 6537 return getRuleContexts(TrTagOpenContext.class); 6538 } 6539 public TrTagOpenContext trTagOpen(int i) { 6540 return getRuleContext(TrTagOpenContext.class,i); 6541 } 6542 public List<TdTagOpenContext> tdTagOpen() { 6543 return getRuleContexts(TdTagOpenContext.class); 6544 } 6545 public TdTagOpenContext tdTagOpen(int i) { 6546 return getRuleContext(TdTagOpenContext.class,i); 6547 } 6548 public List<ThTagOpenContext> thTagOpen() { 6549 return getRuleContexts(ThTagOpenContext.class); 6550 } 6551 public ThTagOpenContext thTagOpen(int i) { 6552 return getRuleContext(ThTagOpenContext.class,i); 6553 } 6554 public List<BodyTagOpenContext> bodyTagOpen() { 6555 return getRuleContexts(BodyTagOpenContext.class); 6556 } 6557 public BodyTagOpenContext bodyTagOpen(int i) { 6558 return getRuleContext(BodyTagOpenContext.class,i); 6559 } 6560 public List<ColgroupTagOpenContext> colgroupTagOpen() { 6561 return getRuleContexts(ColgroupTagOpenContext.class); 6562 } 6563 public ColgroupTagOpenContext colgroupTagOpen(int i) { 6564 return getRuleContext(ColgroupTagOpenContext.class,i); 6565 } 6566 public List<DtTagOpenContext> dtTagOpen() { 6567 return getRuleContexts(DtTagOpenContext.class); 6568 } 6569 public DtTagOpenContext dtTagOpen(int i) { 6570 return getRuleContext(DtTagOpenContext.class,i); 6571 } 6572 public List<HeadTagOpenContext> headTagOpen() { 6573 return getRuleContexts(HeadTagOpenContext.class); 6574 } 6575 public HeadTagOpenContext headTagOpen(int i) { 6576 return getRuleContext(HeadTagOpenContext.class,i); 6577 } 6578 public List<HtmlTagOpenContext> htmlTagOpen() { 6579 return getRuleContexts(HtmlTagOpenContext.class); 6580 } 6581 public HtmlTagOpenContext htmlTagOpen(int i) { 6582 return getRuleContext(HtmlTagOpenContext.class,i); 6583 } 6584 public List<OptionTagOpenContext> optionTagOpen() { 6585 return getRuleContexts(OptionTagOpenContext.class); 6586 } 6587 public OptionTagOpenContext optionTagOpen(int i) { 6588 return getRuleContext(OptionTagOpenContext.class,i); 6589 } 6590 public List<TbodyTagOpenContext> tbodyTagOpen() { 6591 return getRuleContexts(TbodyTagOpenContext.class); 6592 } 6593 public TbodyTagOpenContext tbodyTagOpen(int i) { 6594 return getRuleContext(TbodyTagOpenContext.class,i); 6595 } 6596 public List<TheadTagOpenContext> theadTagOpen() { 6597 return getRuleContexts(TheadTagOpenContext.class); 6598 } 6599 public TheadTagOpenContext theadTagOpen(int i) { 6600 return getRuleContext(TheadTagOpenContext.class,i); 6601 } 6602 public List<TfootTagOpenContext> tfootTagOpen() { 6603 return getRuleContexts(TfootTagOpenContext.class); 6604 } 6605 public TfootTagOpenContext tfootTagOpen(int i) { 6606 return getRuleContext(TfootTagOpenContext.class,i); 6607 } 6608 public List<HtmlCommentContext> htmlComment() { 6609 return getRuleContexts(HtmlCommentContext.class); 6610 } 6611 public HtmlCommentContext htmlComment(int i) { 6612 return getRuleContext(HtmlCommentContext.class,i); 6613 } 6614 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 6615 public TerminalNode CDATA(int i) { 6616 return getToken(JavadocParser.CDATA, i); 6617 } 6618 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6619 public TerminalNode NEWLINE(int i) { 6620 return getToken(JavadocParser.NEWLINE, i); 6621 } 6622 public List<TextContext> text() { 6623 return getRuleContexts(TextContext.class); 6624 } 6625 public TextContext text(int i) { 6626 return getRuleContext(TextContext.class,i); 6627 } 6628 public List<JavadocInlineTagContext> javadocInlineTag() { 6629 return getRuleContexts(JavadocInlineTagContext.class); 6630 } 6631 public JavadocInlineTagContext javadocInlineTag(int i) { 6632 return getRuleContext(JavadocInlineTagContext.class,i); 6633 } 6634 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6635 public TerminalNode LEADING_ASTERISK(int i) { 6636 return getToken(JavadocParser.LEADING_ASTERISK, i); 6637 } 6638 public DdContext(ParserRuleContext parent, int invokingState) { 6639 super(parent, invokingState); 6640 } 6641 @Override public int getRuleIndex() { return RULE_dd; } 6642 @Override 6643 public void enterRule(ParseTreeListener listener) { 6644 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDd(this); 6645 } 6646 @Override 6647 public void exitRule(ParseTreeListener listener) { 6648 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDd(this); 6649 } 6650 @Override 6651 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6652 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDd(this); 6653 else return visitor.visitChildren(this); 6654 } 6655 } 6656 6657 public final DdContext dd() throws RecognitionException { 6658 DdContext _localctx = new DdContext(_ctx, getState()); 6659 enterRule(_localctx, 58, RULE_dd); 6660 try { 6661 int _alt; 6662 enterOuterAlt(_localctx, 1); 6663 { 6664 setState(813); 6665 ddTagOpen(); 6666 setState(853); 6667 _errHandler.sync(this); 6668 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6669 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 6670 if ( _alt==1 ) { 6671 { 6672 setState(851); 6673 _errHandler.sync(this); 6674 switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { 6675 case 1: 6676 { 6677 setState(814); 6678 htmlTag(); 6679 } 6680 break; 6681 case 2: 6682 { 6683 setState(815); 6684 singletonTag(); 6685 } 6686 break; 6687 case 3: 6688 { 6689 setState(816); 6690 paragraph(); 6691 } 6692 break; 6693 case 4: 6694 { 6695 setState(817); 6696 li(); 6697 } 6698 break; 6699 case 5: 6700 { 6701 setState(818); 6702 tr(); 6703 } 6704 break; 6705 case 6: 6706 { 6707 setState(819); 6708 td(); 6709 } 6710 break; 6711 case 7: 6712 { 6713 setState(820); 6714 th(); 6715 } 6716 break; 6717 case 8: 6718 { 6719 setState(821); 6720 body(); 6721 } 6722 break; 6723 case 9: 6724 { 6725 setState(822); 6726 colgroup(); 6727 } 6728 break; 6729 case 10: 6730 { 6731 setState(823); 6732 dt(); 6733 } 6734 break; 6735 case 11: 6736 { 6737 setState(824); 6738 head(); 6739 } 6740 break; 6741 case 12: 6742 { 6743 setState(825); 6744 html(); 6745 } 6746 break; 6747 case 13: 6748 { 6749 setState(826); 6750 option(); 6751 } 6752 break; 6753 case 14: 6754 { 6755 setState(827); 6756 tbody(); 6757 } 6758 break; 6759 case 15: 6760 { 6761 setState(828); 6762 thead(); 6763 } 6764 break; 6765 case 16: 6766 { 6767 setState(829); 6768 tfoot(); 6769 } 6770 break; 6771 case 17: 6772 { 6773 setState(830); 6774 pTagOpen(); 6775 } 6776 break; 6777 case 18: 6778 { 6779 setState(831); 6780 liTagOpen(); 6781 } 6782 break; 6783 case 19: 6784 { 6785 setState(832); 6786 trTagOpen(); 6787 } 6788 break; 6789 case 20: 6790 { 6791 setState(833); 6792 tdTagOpen(); 6793 } 6794 break; 6795 case 21: 6796 { 6797 setState(834); 6798 thTagOpen(); 6799 } 6800 break; 6801 case 22: 6802 { 6803 setState(835); 6804 bodyTagOpen(); 6805 } 6806 break; 6807 case 23: 6808 { 6809 setState(836); 6810 colgroupTagOpen(); 6811 } 6812 break; 6813 case 24: 6814 { 6815 setState(837); 6816 dtTagOpen(); 6817 } 6818 break; 6819 case 25: 6820 { 6821 setState(838); 6822 headTagOpen(); 6823 } 6824 break; 6825 case 26: 6826 { 6827 setState(839); 6828 htmlTagOpen(); 6829 } 6830 break; 6831 case 27: 6832 { 6833 setState(840); 6834 optionTagOpen(); 6835 } 6836 break; 6837 case 28: 6838 { 6839 setState(841); 6840 tbodyTagOpen(); 6841 } 6842 break; 6843 case 29: 6844 { 6845 setState(842); 6846 theadTagOpen(); 6847 } 6848 break; 6849 case 30: 6850 { 6851 setState(843); 6852 tfootTagOpen(); 6853 } 6854 break; 6855 case 31: 6856 { 6857 { 6858 setState(844); 6859 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 6860 setState(845); 6861 match(LEADING_ASTERISK); 6862 } 6863 } 6864 break; 6865 case 32: 6866 { 6867 setState(846); 6868 htmlComment(); 6869 } 6870 break; 6871 case 33: 6872 { 6873 setState(847); 6874 match(CDATA); 6875 } 6876 break; 6877 case 34: 6878 { 6879 setState(848); 6880 match(NEWLINE); 6881 } 6882 break; 6883 case 35: 6884 { 6885 setState(849); 6886 text(); 6887 } 6888 break; 6889 case 36: 6890 { 6891 setState(850); 6892 javadocInlineTag(); 6893 } 6894 break; 6895 } 6896 } 6897 } 6898 setState(855); 6899 _errHandler.sync(this); 6900 _alt = getInterpreter().adaptivePredict(_input,56,_ctx); 6901 } 6902 setState(856); 6903 ddTagClose(); 6904 } 6905 } 6906 catch (RecognitionException re) { 6907 _localctx.exception = re; 6908 _errHandler.reportError(this, re); 6909 _errHandler.recover(this, re); 6910 } 6911 finally { 6912 exitRule(); 6913 } 6914 return _localctx; 6915 } 6916 6917 public static class DtTagOpenContext extends ParserRuleContext { 6918 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 6919 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 6920 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 6921 public List<AttributeContext> attribute() { 6922 return getRuleContexts(AttributeContext.class); 6923 } 6924 public AttributeContext attribute(int i) { 6925 return getRuleContext(AttributeContext.class,i); 6926 } 6927 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 6928 public TerminalNode NEWLINE(int i) { 6929 return getToken(JavadocParser.NEWLINE, i); 6930 } 6931 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 6932 public TerminalNode LEADING_ASTERISK(int i) { 6933 return getToken(JavadocParser.LEADING_ASTERISK, i); 6934 } 6935 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 6936 public TerminalNode WS(int i) { 6937 return getToken(JavadocParser.WS, i); 6938 } 6939 public DtTagOpenContext(ParserRuleContext parent, int invokingState) { 6940 super(parent, invokingState); 6941 } 6942 @Override public int getRuleIndex() { return RULE_dtTagOpen; } 6943 @Override 6944 public void enterRule(ParseTreeListener listener) { 6945 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagOpen(this); 6946 } 6947 @Override 6948 public void exitRule(ParseTreeListener listener) { 6949 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagOpen(this); 6950 } 6951 @Override 6952 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 6953 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagOpen(this); 6954 else return visitor.visitChildren(this); 6955 } 6956 } 6957 6958 public final DtTagOpenContext dtTagOpen() throws RecognitionException { 6959 DtTagOpenContext _localctx = new DtTagOpenContext(_ctx, getState()); 6960 enterRule(_localctx, 60, RULE_dtTagOpen); 6961 int _la; 6962 try { 6963 enterOuterAlt(_localctx, 1); 6964 { 6965 setState(858); 6966 match(OPEN); 6967 setState(859); 6968 match(DT_HTML_TAG_NAME); 6969 setState(866); 6970 _errHandler.sync(this); 6971 _la = _input.LA(1); 6972 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 6973 { 6974 setState(864); 6975 switch (_input.LA(1)) { 6976 case HTML_TAG_NAME: 6977 { 6978 setState(860); 6979 attribute(); 6980 } 6981 break; 6982 case NEWLINE: 6983 { 6984 setState(861); 6985 match(NEWLINE); 6986 } 6987 break; 6988 case LEADING_ASTERISK: 6989 { 6990 setState(862); 6991 match(LEADING_ASTERISK); 6992 } 6993 break; 6994 case WS: 6995 { 6996 setState(863); 6997 match(WS); 6998 } 6999 break; 7000 default: 7001 throw new NoViableAltException(this); 7002 } 7003 } 7004 setState(868); 7005 _errHandler.sync(this); 7006 _la = _input.LA(1); 7007 } 7008 setState(869); 7009 match(CLOSE); 7010 } 7011 } 7012 catch (RecognitionException re) { 7013 _localctx.exception = re; 7014 _errHandler.reportError(this, re); 7015 _errHandler.recover(this, re); 7016 } 7017 finally { 7018 exitRule(); 7019 } 7020 return _localctx; 7021 } 7022 7023 public static class DtTagCloseContext extends ParserRuleContext { 7024 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7025 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7026 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 7027 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7028 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7029 public TerminalNode NEWLINE(int i) { 7030 return getToken(JavadocParser.NEWLINE, i); 7031 } 7032 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7033 public TerminalNode LEADING_ASTERISK(int i) { 7034 return getToken(JavadocParser.LEADING_ASTERISK, i); 7035 } 7036 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7037 public TerminalNode WS(int i) { 7038 return getToken(JavadocParser.WS, i); 7039 } 7040 public DtTagCloseContext(ParserRuleContext parent, int invokingState) { 7041 super(parent, invokingState); 7042 } 7043 @Override public int getRuleIndex() { return RULE_dtTagClose; } 7044 @Override 7045 public void enterRule(ParseTreeListener listener) { 7046 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDtTagClose(this); 7047 } 7048 @Override 7049 public void exitRule(ParseTreeListener listener) { 7050 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDtTagClose(this); 7051 } 7052 @Override 7053 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7054 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagClose(this); 7055 else return visitor.visitChildren(this); 7056 } 7057 } 7058 7059 public final DtTagCloseContext dtTagClose() throws RecognitionException { 7060 DtTagCloseContext _localctx = new DtTagCloseContext(_ctx, getState()); 7061 enterRule(_localctx, 62, RULE_dtTagClose); 7062 int _la; 7063 try { 7064 enterOuterAlt(_localctx, 1); 7065 { 7066 setState(871); 7067 match(OPEN); 7068 setState(872); 7069 match(SLASH); 7070 setState(873); 7071 match(DT_HTML_TAG_NAME); 7072 setState(877); 7073 _errHandler.sync(this); 7074 _la = _input.LA(1); 7075 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7076 { 7077 { 7078 setState(874); 7079 _la = _input.LA(1); 7080 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7081 _errHandler.recoverInline(this); 7082 } else { 7083 consume(); 7084 } 7085 } 7086 } 7087 setState(879); 7088 _errHandler.sync(this); 7089 _la = _input.LA(1); 7090 } 7091 setState(880); 7092 match(CLOSE); 7093 } 7094 } 7095 catch (RecognitionException re) { 7096 _localctx.exception = re; 7097 _errHandler.reportError(this, re); 7098 _errHandler.recover(this, re); 7099 } 7100 finally { 7101 exitRule(); 7102 } 7103 return _localctx; 7104 } 7105 7106 public static class DtContext extends ParserRuleContext { 7107 public DtTagOpenContext dtTagOpen() { 7108 return getRuleContext(DtTagOpenContext.class,0); 7109 } 7110 public DtTagCloseContext dtTagClose() { 7111 return getRuleContext(DtTagCloseContext.class,0); 7112 } 7113 public List<HtmlTagContext> htmlTag() { 7114 return getRuleContexts(HtmlTagContext.class); 7115 } 7116 public HtmlTagContext htmlTag(int i) { 7117 return getRuleContext(HtmlTagContext.class,i); 7118 } 7119 public List<SingletonTagContext> singletonTag() { 7120 return getRuleContexts(SingletonTagContext.class); 7121 } 7122 public SingletonTagContext singletonTag(int i) { 7123 return getRuleContext(SingletonTagContext.class,i); 7124 } 7125 public List<ParagraphContext> paragraph() { 7126 return getRuleContexts(ParagraphContext.class); 7127 } 7128 public ParagraphContext paragraph(int i) { 7129 return getRuleContext(ParagraphContext.class,i); 7130 } 7131 public List<LiContext> li() { 7132 return getRuleContexts(LiContext.class); 7133 } 7134 public LiContext li(int i) { 7135 return getRuleContext(LiContext.class,i); 7136 } 7137 public List<TrContext> tr() { 7138 return getRuleContexts(TrContext.class); 7139 } 7140 public TrContext tr(int i) { 7141 return getRuleContext(TrContext.class,i); 7142 } 7143 public List<TdContext> td() { 7144 return getRuleContexts(TdContext.class); 7145 } 7146 public TdContext td(int i) { 7147 return getRuleContext(TdContext.class,i); 7148 } 7149 public List<ThContext> th() { 7150 return getRuleContexts(ThContext.class); 7151 } 7152 public ThContext th(int i) { 7153 return getRuleContext(ThContext.class,i); 7154 } 7155 public List<BodyContext> body() { 7156 return getRuleContexts(BodyContext.class); 7157 } 7158 public BodyContext body(int i) { 7159 return getRuleContext(BodyContext.class,i); 7160 } 7161 public List<ColgroupContext> colgroup() { 7162 return getRuleContexts(ColgroupContext.class); 7163 } 7164 public ColgroupContext colgroup(int i) { 7165 return getRuleContext(ColgroupContext.class,i); 7166 } 7167 public List<DdContext> dd() { 7168 return getRuleContexts(DdContext.class); 7169 } 7170 public DdContext dd(int i) { 7171 return getRuleContext(DdContext.class,i); 7172 } 7173 public List<HeadContext> head() { 7174 return getRuleContexts(HeadContext.class); 7175 } 7176 public HeadContext head(int i) { 7177 return getRuleContext(HeadContext.class,i); 7178 } 7179 public List<HtmlContext> html() { 7180 return getRuleContexts(HtmlContext.class); 7181 } 7182 public HtmlContext html(int i) { 7183 return getRuleContext(HtmlContext.class,i); 7184 } 7185 public List<OptionContext> option() { 7186 return getRuleContexts(OptionContext.class); 7187 } 7188 public OptionContext option(int i) { 7189 return getRuleContext(OptionContext.class,i); 7190 } 7191 public List<TbodyContext> tbody() { 7192 return getRuleContexts(TbodyContext.class); 7193 } 7194 public TbodyContext tbody(int i) { 7195 return getRuleContext(TbodyContext.class,i); 7196 } 7197 public List<TheadContext> thead() { 7198 return getRuleContexts(TheadContext.class); 7199 } 7200 public TheadContext thead(int i) { 7201 return getRuleContext(TheadContext.class,i); 7202 } 7203 public List<TfootContext> tfoot() { 7204 return getRuleContexts(TfootContext.class); 7205 } 7206 public TfootContext tfoot(int i) { 7207 return getRuleContext(TfootContext.class,i); 7208 } 7209 public List<PTagOpenContext> pTagOpen() { 7210 return getRuleContexts(PTagOpenContext.class); 7211 } 7212 public PTagOpenContext pTagOpen(int i) { 7213 return getRuleContext(PTagOpenContext.class,i); 7214 } 7215 public List<LiTagOpenContext> liTagOpen() { 7216 return getRuleContexts(LiTagOpenContext.class); 7217 } 7218 public LiTagOpenContext liTagOpen(int i) { 7219 return getRuleContext(LiTagOpenContext.class,i); 7220 } 7221 public List<TrTagOpenContext> trTagOpen() { 7222 return getRuleContexts(TrTagOpenContext.class); 7223 } 7224 public TrTagOpenContext trTagOpen(int i) { 7225 return getRuleContext(TrTagOpenContext.class,i); 7226 } 7227 public List<TdTagOpenContext> tdTagOpen() { 7228 return getRuleContexts(TdTagOpenContext.class); 7229 } 7230 public TdTagOpenContext tdTagOpen(int i) { 7231 return getRuleContext(TdTagOpenContext.class,i); 7232 } 7233 public List<ThTagOpenContext> thTagOpen() { 7234 return getRuleContexts(ThTagOpenContext.class); 7235 } 7236 public ThTagOpenContext thTagOpen(int i) { 7237 return getRuleContext(ThTagOpenContext.class,i); 7238 } 7239 public List<BodyTagOpenContext> bodyTagOpen() { 7240 return getRuleContexts(BodyTagOpenContext.class); 7241 } 7242 public BodyTagOpenContext bodyTagOpen(int i) { 7243 return getRuleContext(BodyTagOpenContext.class,i); 7244 } 7245 public List<ColgroupTagOpenContext> colgroupTagOpen() { 7246 return getRuleContexts(ColgroupTagOpenContext.class); 7247 } 7248 public ColgroupTagOpenContext colgroupTagOpen(int i) { 7249 return getRuleContext(ColgroupTagOpenContext.class,i); 7250 } 7251 public List<DdTagOpenContext> ddTagOpen() { 7252 return getRuleContexts(DdTagOpenContext.class); 7253 } 7254 public DdTagOpenContext ddTagOpen(int i) { 7255 return getRuleContext(DdTagOpenContext.class,i); 7256 } 7257 public List<HeadTagOpenContext> headTagOpen() { 7258 return getRuleContexts(HeadTagOpenContext.class); 7259 } 7260 public HeadTagOpenContext headTagOpen(int i) { 7261 return getRuleContext(HeadTagOpenContext.class,i); 7262 } 7263 public List<HtmlTagOpenContext> htmlTagOpen() { 7264 return getRuleContexts(HtmlTagOpenContext.class); 7265 } 7266 public HtmlTagOpenContext htmlTagOpen(int i) { 7267 return getRuleContext(HtmlTagOpenContext.class,i); 7268 } 7269 public List<OptionTagOpenContext> optionTagOpen() { 7270 return getRuleContexts(OptionTagOpenContext.class); 7271 } 7272 public OptionTagOpenContext optionTagOpen(int i) { 7273 return getRuleContext(OptionTagOpenContext.class,i); 7274 } 7275 public List<TbodyTagOpenContext> tbodyTagOpen() { 7276 return getRuleContexts(TbodyTagOpenContext.class); 7277 } 7278 public TbodyTagOpenContext tbodyTagOpen(int i) { 7279 return getRuleContext(TbodyTagOpenContext.class,i); 7280 } 7281 public List<TheadTagOpenContext> theadTagOpen() { 7282 return getRuleContexts(TheadTagOpenContext.class); 7283 } 7284 public TheadTagOpenContext theadTagOpen(int i) { 7285 return getRuleContext(TheadTagOpenContext.class,i); 7286 } 7287 public List<TfootTagOpenContext> tfootTagOpen() { 7288 return getRuleContexts(TfootTagOpenContext.class); 7289 } 7290 public TfootTagOpenContext tfootTagOpen(int i) { 7291 return getRuleContext(TfootTagOpenContext.class,i); 7292 } 7293 public List<HtmlCommentContext> htmlComment() { 7294 return getRuleContexts(HtmlCommentContext.class); 7295 } 7296 public HtmlCommentContext htmlComment(int i) { 7297 return getRuleContext(HtmlCommentContext.class,i); 7298 } 7299 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 7300 public TerminalNode CDATA(int i) { 7301 return getToken(JavadocParser.CDATA, i); 7302 } 7303 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7304 public TerminalNode NEWLINE(int i) { 7305 return getToken(JavadocParser.NEWLINE, i); 7306 } 7307 public List<TextContext> text() { 7308 return getRuleContexts(TextContext.class); 7309 } 7310 public TextContext text(int i) { 7311 return getRuleContext(TextContext.class,i); 7312 } 7313 public List<JavadocInlineTagContext> javadocInlineTag() { 7314 return getRuleContexts(JavadocInlineTagContext.class); 7315 } 7316 public JavadocInlineTagContext javadocInlineTag(int i) { 7317 return getRuleContext(JavadocInlineTagContext.class,i); 7318 } 7319 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7320 public TerminalNode LEADING_ASTERISK(int i) { 7321 return getToken(JavadocParser.LEADING_ASTERISK, i); 7322 } 7323 public DtContext(ParserRuleContext parent, int invokingState) { 7324 super(parent, invokingState); 7325 } 7326 @Override public int getRuleIndex() { return RULE_dt; } 7327 @Override 7328 public void enterRule(ParseTreeListener listener) { 7329 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDt(this); 7330 } 7331 @Override 7332 public void exitRule(ParseTreeListener listener) { 7333 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDt(this); 7334 } 7335 @Override 7336 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7337 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDt(this); 7338 else return visitor.visitChildren(this); 7339 } 7340 } 7341 7342 public final DtContext dt() throws RecognitionException { 7343 DtContext _localctx = new DtContext(_ctx, getState()); 7344 enterRule(_localctx, 64, RULE_dt); 7345 try { 7346 int _alt; 7347 enterOuterAlt(_localctx, 1); 7348 { 7349 setState(882); 7350 dtTagOpen(); 7351 setState(922); 7352 _errHandler.sync(this); 7353 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 7354 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 7355 if ( _alt==1 ) { 7356 { 7357 setState(920); 7358 _errHandler.sync(this); 7359 switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { 7360 case 1: 7361 { 7362 setState(883); 7363 htmlTag(); 7364 } 7365 break; 7366 case 2: 7367 { 7368 setState(884); 7369 singletonTag(); 7370 } 7371 break; 7372 case 3: 7373 { 7374 setState(885); 7375 paragraph(); 7376 } 7377 break; 7378 case 4: 7379 { 7380 setState(886); 7381 li(); 7382 } 7383 break; 7384 case 5: 7385 { 7386 setState(887); 7387 tr(); 7388 } 7389 break; 7390 case 6: 7391 { 7392 setState(888); 7393 td(); 7394 } 7395 break; 7396 case 7: 7397 { 7398 setState(889); 7399 th(); 7400 } 7401 break; 7402 case 8: 7403 { 7404 setState(890); 7405 body(); 7406 } 7407 break; 7408 case 9: 7409 { 7410 setState(891); 7411 colgroup(); 7412 } 7413 break; 7414 case 10: 7415 { 7416 setState(892); 7417 dd(); 7418 } 7419 break; 7420 case 11: 7421 { 7422 setState(893); 7423 head(); 7424 } 7425 break; 7426 case 12: 7427 { 7428 setState(894); 7429 html(); 7430 } 7431 break; 7432 case 13: 7433 { 7434 setState(895); 7435 option(); 7436 } 7437 break; 7438 case 14: 7439 { 7440 setState(896); 7441 tbody(); 7442 } 7443 break; 7444 case 15: 7445 { 7446 setState(897); 7447 thead(); 7448 } 7449 break; 7450 case 16: 7451 { 7452 setState(898); 7453 tfoot(); 7454 } 7455 break; 7456 case 17: 7457 { 7458 setState(899); 7459 pTagOpen(); 7460 } 7461 break; 7462 case 18: 7463 { 7464 setState(900); 7465 liTagOpen(); 7466 } 7467 break; 7468 case 19: 7469 { 7470 setState(901); 7471 trTagOpen(); 7472 } 7473 break; 7474 case 20: 7475 { 7476 setState(902); 7477 tdTagOpen(); 7478 } 7479 break; 7480 case 21: 7481 { 7482 setState(903); 7483 thTagOpen(); 7484 } 7485 break; 7486 case 22: 7487 { 7488 setState(904); 7489 bodyTagOpen(); 7490 } 7491 break; 7492 case 23: 7493 { 7494 setState(905); 7495 colgroupTagOpen(); 7496 } 7497 break; 7498 case 24: 7499 { 7500 setState(906); 7501 ddTagOpen(); 7502 } 7503 break; 7504 case 25: 7505 { 7506 setState(907); 7507 headTagOpen(); 7508 } 7509 break; 7510 case 26: 7511 { 7512 setState(908); 7513 htmlTagOpen(); 7514 } 7515 break; 7516 case 27: 7517 { 7518 setState(909); 7519 optionTagOpen(); 7520 } 7521 break; 7522 case 28: 7523 { 7524 setState(910); 7525 tbodyTagOpen(); 7526 } 7527 break; 7528 case 29: 7529 { 7530 setState(911); 7531 theadTagOpen(); 7532 } 7533 break; 7534 case 30: 7535 { 7536 setState(912); 7537 tfootTagOpen(); 7538 } 7539 break; 7540 case 31: 7541 { 7542 { 7543 setState(913); 7544 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 7545 setState(914); 7546 match(LEADING_ASTERISK); 7547 } 7548 } 7549 break; 7550 case 32: 7551 { 7552 setState(915); 7553 htmlComment(); 7554 } 7555 break; 7556 case 33: 7557 { 7558 setState(916); 7559 match(CDATA); 7560 } 7561 break; 7562 case 34: 7563 { 7564 setState(917); 7565 match(NEWLINE); 7566 } 7567 break; 7568 case 35: 7569 { 7570 setState(918); 7571 text(); 7572 } 7573 break; 7574 case 36: 7575 { 7576 setState(919); 7577 javadocInlineTag(); 7578 } 7579 break; 7580 } 7581 } 7582 } 7583 setState(924); 7584 _errHandler.sync(this); 7585 _alt = getInterpreter().adaptivePredict(_input,61,_ctx); 7586 } 7587 setState(925); 7588 dtTagClose(); 7589 } 7590 } 7591 catch (RecognitionException re) { 7592 _localctx.exception = re; 7593 _errHandler.reportError(this, re); 7594 _errHandler.recover(this, re); 7595 } 7596 finally { 7597 exitRule(); 7598 } 7599 return _localctx; 7600 } 7601 7602 public static class HeadTagOpenContext extends ParserRuleContext { 7603 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7604 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7605 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7606 public List<AttributeContext> attribute() { 7607 return getRuleContexts(AttributeContext.class); 7608 } 7609 public AttributeContext attribute(int i) { 7610 return getRuleContext(AttributeContext.class,i); 7611 } 7612 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7613 public TerminalNode NEWLINE(int i) { 7614 return getToken(JavadocParser.NEWLINE, i); 7615 } 7616 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7617 public TerminalNode LEADING_ASTERISK(int i) { 7618 return getToken(JavadocParser.LEADING_ASTERISK, i); 7619 } 7620 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7621 public TerminalNode WS(int i) { 7622 return getToken(JavadocParser.WS, i); 7623 } 7624 public HeadTagOpenContext(ParserRuleContext parent, int invokingState) { 7625 super(parent, invokingState); 7626 } 7627 @Override public int getRuleIndex() { return RULE_headTagOpen; } 7628 @Override 7629 public void enterRule(ParseTreeListener listener) { 7630 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagOpen(this); 7631 } 7632 @Override 7633 public void exitRule(ParseTreeListener listener) { 7634 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagOpen(this); 7635 } 7636 @Override 7637 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7638 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagOpen(this); 7639 else return visitor.visitChildren(this); 7640 } 7641 } 7642 7643 public final HeadTagOpenContext headTagOpen() throws RecognitionException { 7644 HeadTagOpenContext _localctx = new HeadTagOpenContext(_ctx, getState()); 7645 enterRule(_localctx, 66, RULE_headTagOpen); 7646 int _la; 7647 try { 7648 enterOuterAlt(_localctx, 1); 7649 { 7650 setState(927); 7651 match(OPEN); 7652 setState(928); 7653 match(HEAD_HTML_TAG_NAME); 7654 setState(935); 7655 _errHandler.sync(this); 7656 _la = _input.LA(1); 7657 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 7658 { 7659 setState(933); 7660 switch (_input.LA(1)) { 7661 case HTML_TAG_NAME: 7662 { 7663 setState(929); 7664 attribute(); 7665 } 7666 break; 7667 case NEWLINE: 7668 { 7669 setState(930); 7670 match(NEWLINE); 7671 } 7672 break; 7673 case LEADING_ASTERISK: 7674 { 7675 setState(931); 7676 match(LEADING_ASTERISK); 7677 } 7678 break; 7679 case WS: 7680 { 7681 setState(932); 7682 match(WS); 7683 } 7684 break; 7685 default: 7686 throw new NoViableAltException(this); 7687 } 7688 } 7689 setState(937); 7690 _errHandler.sync(this); 7691 _la = _input.LA(1); 7692 } 7693 setState(938); 7694 match(CLOSE); 7695 } 7696 } 7697 catch (RecognitionException re) { 7698 _localctx.exception = re; 7699 _errHandler.reportError(this, re); 7700 _errHandler.recover(this, re); 7701 } 7702 finally { 7703 exitRule(); 7704 } 7705 return _localctx; 7706 } 7707 7708 public static class HeadTagCloseContext extends ParserRuleContext { 7709 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 7710 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 7711 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 7712 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 7713 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7714 public TerminalNode NEWLINE(int i) { 7715 return getToken(JavadocParser.NEWLINE, i); 7716 } 7717 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 7718 public TerminalNode LEADING_ASTERISK(int i) { 7719 return getToken(JavadocParser.LEADING_ASTERISK, i); 7720 } 7721 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 7722 public TerminalNode WS(int i) { 7723 return getToken(JavadocParser.WS, i); 7724 } 7725 public HeadTagCloseContext(ParserRuleContext parent, int invokingState) { 7726 super(parent, invokingState); 7727 } 7728 @Override public int getRuleIndex() { return RULE_headTagClose; } 7729 @Override 7730 public void enterRule(ParseTreeListener listener) { 7731 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHeadTagClose(this); 7732 } 7733 @Override 7734 public void exitRule(ParseTreeListener listener) { 7735 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHeadTagClose(this); 7736 } 7737 @Override 7738 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 7739 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagClose(this); 7740 else return visitor.visitChildren(this); 7741 } 7742 } 7743 7744 public final HeadTagCloseContext headTagClose() throws RecognitionException { 7745 HeadTagCloseContext _localctx = new HeadTagCloseContext(_ctx, getState()); 7746 enterRule(_localctx, 68, RULE_headTagClose); 7747 int _la; 7748 try { 7749 enterOuterAlt(_localctx, 1); 7750 { 7751 setState(940); 7752 match(OPEN); 7753 setState(941); 7754 match(SLASH); 7755 setState(942); 7756 match(HEAD_HTML_TAG_NAME); 7757 setState(946); 7758 _errHandler.sync(this); 7759 _la = _input.LA(1); 7760 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 7761 { 7762 { 7763 setState(943); 7764 _la = _input.LA(1); 7765 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 7766 _errHandler.recoverInline(this); 7767 } else { 7768 consume(); 7769 } 7770 } 7771 } 7772 setState(948); 7773 _errHandler.sync(this); 7774 _la = _input.LA(1); 7775 } 7776 setState(949); 7777 match(CLOSE); 7778 } 7779 } 7780 catch (RecognitionException re) { 7781 _localctx.exception = re; 7782 _errHandler.reportError(this, re); 7783 _errHandler.recover(this, re); 7784 } 7785 finally { 7786 exitRule(); 7787 } 7788 return _localctx; 7789 } 7790 7791 public static class HeadContext extends ParserRuleContext { 7792 public HeadTagOpenContext headTagOpen() { 7793 return getRuleContext(HeadTagOpenContext.class,0); 7794 } 7795 public HeadTagCloseContext headTagClose() { 7796 return getRuleContext(HeadTagCloseContext.class,0); 7797 } 7798 public List<HtmlTagContext> htmlTag() { 7799 return getRuleContexts(HtmlTagContext.class); 7800 } 7801 public HtmlTagContext htmlTag(int i) { 7802 return getRuleContext(HtmlTagContext.class,i); 7803 } 7804 public List<SingletonTagContext> singletonTag() { 7805 return getRuleContexts(SingletonTagContext.class); 7806 } 7807 public SingletonTagContext singletonTag(int i) { 7808 return getRuleContext(SingletonTagContext.class,i); 7809 } 7810 public List<ParagraphContext> paragraph() { 7811 return getRuleContexts(ParagraphContext.class); 7812 } 7813 public ParagraphContext paragraph(int i) { 7814 return getRuleContext(ParagraphContext.class,i); 7815 } 7816 public List<LiContext> li() { 7817 return getRuleContexts(LiContext.class); 7818 } 7819 public LiContext li(int i) { 7820 return getRuleContext(LiContext.class,i); 7821 } 7822 public List<TrContext> tr() { 7823 return getRuleContexts(TrContext.class); 7824 } 7825 public TrContext tr(int i) { 7826 return getRuleContext(TrContext.class,i); 7827 } 7828 public List<TdContext> td() { 7829 return getRuleContexts(TdContext.class); 7830 } 7831 public TdContext td(int i) { 7832 return getRuleContext(TdContext.class,i); 7833 } 7834 public List<ThContext> th() { 7835 return getRuleContexts(ThContext.class); 7836 } 7837 public ThContext th(int i) { 7838 return getRuleContext(ThContext.class,i); 7839 } 7840 public List<BodyContext> body() { 7841 return getRuleContexts(BodyContext.class); 7842 } 7843 public BodyContext body(int i) { 7844 return getRuleContext(BodyContext.class,i); 7845 } 7846 public List<ColgroupContext> colgroup() { 7847 return getRuleContexts(ColgroupContext.class); 7848 } 7849 public ColgroupContext colgroup(int i) { 7850 return getRuleContext(ColgroupContext.class,i); 7851 } 7852 public List<DdContext> dd() { 7853 return getRuleContexts(DdContext.class); 7854 } 7855 public DdContext dd(int i) { 7856 return getRuleContext(DdContext.class,i); 7857 } 7858 public List<DtContext> dt() { 7859 return getRuleContexts(DtContext.class); 7860 } 7861 public DtContext dt(int i) { 7862 return getRuleContext(DtContext.class,i); 7863 } 7864 public List<HtmlContext> html() { 7865 return getRuleContexts(HtmlContext.class); 7866 } 7867 public HtmlContext html(int i) { 7868 return getRuleContext(HtmlContext.class,i); 7869 } 7870 public List<OptionContext> option() { 7871 return getRuleContexts(OptionContext.class); 7872 } 7873 public OptionContext option(int i) { 7874 return getRuleContext(OptionContext.class,i); 7875 } 7876 public List<TbodyContext> tbody() { 7877 return getRuleContexts(TbodyContext.class); 7878 } 7879 public TbodyContext tbody(int i) { 7880 return getRuleContext(TbodyContext.class,i); 7881 } 7882 public List<TheadContext> thead() { 7883 return getRuleContexts(TheadContext.class); 7884 } 7885 public TheadContext thead(int i) { 7886 return getRuleContext(TheadContext.class,i); 7887 } 7888 public List<TfootContext> tfoot() { 7889 return getRuleContexts(TfootContext.class); 7890 } 7891 public TfootContext tfoot(int i) { 7892 return getRuleContext(TfootContext.class,i); 7893 } 7894 public List<PTagOpenContext> pTagOpen() { 7895 return getRuleContexts(PTagOpenContext.class); 7896 } 7897 public PTagOpenContext pTagOpen(int i) { 7898 return getRuleContext(PTagOpenContext.class,i); 7899 } 7900 public List<LiTagOpenContext> liTagOpen() { 7901 return getRuleContexts(LiTagOpenContext.class); 7902 } 7903 public LiTagOpenContext liTagOpen(int i) { 7904 return getRuleContext(LiTagOpenContext.class,i); 7905 } 7906 public List<TrTagOpenContext> trTagOpen() { 7907 return getRuleContexts(TrTagOpenContext.class); 7908 } 7909 public TrTagOpenContext trTagOpen(int i) { 7910 return getRuleContext(TrTagOpenContext.class,i); 7911 } 7912 public List<TdTagOpenContext> tdTagOpen() { 7913 return getRuleContexts(TdTagOpenContext.class); 7914 } 7915 public TdTagOpenContext tdTagOpen(int i) { 7916 return getRuleContext(TdTagOpenContext.class,i); 7917 } 7918 public List<ThTagOpenContext> thTagOpen() { 7919 return getRuleContexts(ThTagOpenContext.class); 7920 } 7921 public ThTagOpenContext thTagOpen(int i) { 7922 return getRuleContext(ThTagOpenContext.class,i); 7923 } 7924 public List<BodyTagOpenContext> bodyTagOpen() { 7925 return getRuleContexts(BodyTagOpenContext.class); 7926 } 7927 public BodyTagOpenContext bodyTagOpen(int i) { 7928 return getRuleContext(BodyTagOpenContext.class,i); 7929 } 7930 public List<ColgroupTagOpenContext> colgroupTagOpen() { 7931 return getRuleContexts(ColgroupTagOpenContext.class); 7932 } 7933 public ColgroupTagOpenContext colgroupTagOpen(int i) { 7934 return getRuleContext(ColgroupTagOpenContext.class,i); 7935 } 7936 public List<DdTagOpenContext> ddTagOpen() { 7937 return getRuleContexts(DdTagOpenContext.class); 7938 } 7939 public DdTagOpenContext ddTagOpen(int i) { 7940 return getRuleContext(DdTagOpenContext.class,i); 7941 } 7942 public List<DtTagOpenContext> dtTagOpen() { 7943 return getRuleContexts(DtTagOpenContext.class); 7944 } 7945 public DtTagOpenContext dtTagOpen(int i) { 7946 return getRuleContext(DtTagOpenContext.class,i); 7947 } 7948 public List<HtmlTagOpenContext> htmlTagOpen() { 7949 return getRuleContexts(HtmlTagOpenContext.class); 7950 } 7951 public HtmlTagOpenContext htmlTagOpen(int i) { 7952 return getRuleContext(HtmlTagOpenContext.class,i); 7953 } 7954 public List<OptionTagOpenContext> optionTagOpen() { 7955 return getRuleContexts(OptionTagOpenContext.class); 7956 } 7957 public OptionTagOpenContext optionTagOpen(int i) { 7958 return getRuleContext(OptionTagOpenContext.class,i); 7959 } 7960 public List<TbodyTagOpenContext> tbodyTagOpen() { 7961 return getRuleContexts(TbodyTagOpenContext.class); 7962 } 7963 public TbodyTagOpenContext tbodyTagOpen(int i) { 7964 return getRuleContext(TbodyTagOpenContext.class,i); 7965 } 7966 public List<TheadTagOpenContext> theadTagOpen() { 7967 return getRuleContexts(TheadTagOpenContext.class); 7968 } 7969 public TheadTagOpenContext theadTagOpen(int i) { 7970 return getRuleContext(TheadTagOpenContext.class,i); 7971 } 7972 public List<TfootTagOpenContext> tfootTagOpen() { 7973 return getRuleContexts(TfootTagOpenContext.class); 7974 } 7975 public TfootTagOpenContext tfootTagOpen(int i) { 7976 return getRuleContext(TfootTagOpenContext.class,i); 7977 } 7978 public List<HtmlCommentContext> htmlComment() { 7979 return getRuleContexts(HtmlCommentContext.class); 7980 } 7981 public HtmlCommentContext htmlComment(int i) { 7982 return getRuleContext(HtmlCommentContext.class,i); 7983 } 7984 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 7985 public TerminalNode CDATA(int i) { 7986 return getToken(JavadocParser.CDATA, i); 7987 } 7988 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 7989 public TerminalNode NEWLINE(int i) { 7990 return getToken(JavadocParser.NEWLINE, i); 7991 } 7992 public List<TextContext> text() { 7993 return getRuleContexts(TextContext.class); 7994 } 7995 public TextContext text(int i) { 7996 return getRuleContext(TextContext.class,i); 7997 } 7998 public List<JavadocInlineTagContext> javadocInlineTag() { 7999 return getRuleContexts(JavadocInlineTagContext.class); 8000 } 8001 public JavadocInlineTagContext javadocInlineTag(int i) { 8002 return getRuleContext(JavadocInlineTagContext.class,i); 8003 } 8004 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8005 public TerminalNode LEADING_ASTERISK(int i) { 8006 return getToken(JavadocParser.LEADING_ASTERISK, i); 8007 } 8008 public HeadContext(ParserRuleContext parent, int invokingState) { 8009 super(parent, invokingState); 8010 } 8011 @Override public int getRuleIndex() { return RULE_head; } 8012 @Override 8013 public void enterRule(ParseTreeListener listener) { 8014 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHead(this); 8015 } 8016 @Override 8017 public void exitRule(ParseTreeListener listener) { 8018 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHead(this); 8019 } 8020 @Override 8021 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8022 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHead(this); 8023 else return visitor.visitChildren(this); 8024 } 8025 } 8026 8027 public final HeadContext head() throws RecognitionException { 8028 HeadContext _localctx = new HeadContext(_ctx, getState()); 8029 enterRule(_localctx, 70, RULE_head); 8030 try { 8031 int _alt; 8032 enterOuterAlt(_localctx, 1); 8033 { 8034 setState(951); 8035 headTagOpen(); 8036 setState(991); 8037 _errHandler.sync(this); 8038 _alt = getInterpreter().adaptivePredict(_input,66,_ctx); 8039 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8040 if ( _alt==1 ) { 8041 { 8042 setState(989); 8043 _errHandler.sync(this); 8044 switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) { 8045 case 1: 8046 { 8047 setState(952); 8048 htmlTag(); 8049 } 8050 break; 8051 case 2: 8052 { 8053 setState(953); 8054 singletonTag(); 8055 } 8056 break; 8057 case 3: 8058 { 8059 setState(954); 8060 paragraph(); 8061 } 8062 break; 8063 case 4: 8064 { 8065 setState(955); 8066 li(); 8067 } 8068 break; 8069 case 5: 8070 { 8071 setState(956); 8072 tr(); 8073 } 8074 break; 8075 case 6: 8076 { 8077 setState(957); 8078 td(); 8079 } 8080 break; 8081 case 7: 8082 { 8083 setState(958); 8084 th(); 8085 } 8086 break; 8087 case 8: 8088 { 8089 setState(959); 8090 body(); 8091 } 8092 break; 8093 case 9: 8094 { 8095 setState(960); 8096 colgroup(); 8097 } 8098 break; 8099 case 10: 8100 { 8101 setState(961); 8102 dd(); 8103 } 8104 break; 8105 case 11: 8106 { 8107 setState(962); 8108 dt(); 8109 } 8110 break; 8111 case 12: 8112 { 8113 setState(963); 8114 html(); 8115 } 8116 break; 8117 case 13: 8118 { 8119 setState(964); 8120 option(); 8121 } 8122 break; 8123 case 14: 8124 { 8125 setState(965); 8126 tbody(); 8127 } 8128 break; 8129 case 15: 8130 { 8131 setState(966); 8132 thead(); 8133 } 8134 break; 8135 case 16: 8136 { 8137 setState(967); 8138 tfoot(); 8139 } 8140 break; 8141 case 17: 8142 { 8143 setState(968); 8144 pTagOpen(); 8145 } 8146 break; 8147 case 18: 8148 { 8149 setState(969); 8150 liTagOpen(); 8151 } 8152 break; 8153 case 19: 8154 { 8155 setState(970); 8156 trTagOpen(); 8157 } 8158 break; 8159 case 20: 8160 { 8161 setState(971); 8162 tdTagOpen(); 8163 } 8164 break; 8165 case 21: 8166 { 8167 setState(972); 8168 thTagOpen(); 8169 } 8170 break; 8171 case 22: 8172 { 8173 setState(973); 8174 bodyTagOpen(); 8175 } 8176 break; 8177 case 23: 8178 { 8179 setState(974); 8180 colgroupTagOpen(); 8181 } 8182 break; 8183 case 24: 8184 { 8185 setState(975); 8186 ddTagOpen(); 8187 } 8188 break; 8189 case 25: 8190 { 8191 setState(976); 8192 dtTagOpen(); 8193 } 8194 break; 8195 case 26: 8196 { 8197 setState(977); 8198 htmlTagOpen(); 8199 } 8200 break; 8201 case 27: 8202 { 8203 setState(978); 8204 optionTagOpen(); 8205 } 8206 break; 8207 case 28: 8208 { 8209 setState(979); 8210 tbodyTagOpen(); 8211 } 8212 break; 8213 case 29: 8214 { 8215 setState(980); 8216 theadTagOpen(); 8217 } 8218 break; 8219 case 30: 8220 { 8221 setState(981); 8222 tfootTagOpen(); 8223 } 8224 break; 8225 case 31: 8226 { 8227 { 8228 setState(982); 8229 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8230 setState(983); 8231 match(LEADING_ASTERISK); 8232 } 8233 } 8234 break; 8235 case 32: 8236 { 8237 setState(984); 8238 htmlComment(); 8239 } 8240 break; 8241 case 33: 8242 { 8243 setState(985); 8244 match(CDATA); 8245 } 8246 break; 8247 case 34: 8248 { 8249 setState(986); 8250 match(NEWLINE); 8251 } 8252 break; 8253 case 35: 8254 { 8255 setState(987); 8256 text(); 8257 } 8258 break; 8259 case 36: 8260 { 8261 setState(988); 8262 javadocInlineTag(); 8263 } 8264 break; 8265 } 8266 } 8267 } 8268 setState(993); 8269 _errHandler.sync(this); 8270 _alt = getInterpreter().adaptivePredict(_input,66,_ctx); 8271 } 8272 setState(994); 8273 headTagClose(); 8274 } 8275 } 8276 catch (RecognitionException re) { 8277 _localctx.exception = re; 8278 _errHandler.reportError(this, re); 8279 _errHandler.recover(this, re); 8280 } 8281 finally { 8282 exitRule(); 8283 } 8284 return _localctx; 8285 } 8286 8287 public static class HtmlTagOpenContext extends ParserRuleContext { 8288 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8289 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 8290 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8291 public List<AttributeContext> attribute() { 8292 return getRuleContexts(AttributeContext.class); 8293 } 8294 public AttributeContext attribute(int i) { 8295 return getRuleContext(AttributeContext.class,i); 8296 } 8297 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8298 public TerminalNode NEWLINE(int i) { 8299 return getToken(JavadocParser.NEWLINE, i); 8300 } 8301 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8302 public TerminalNode LEADING_ASTERISK(int i) { 8303 return getToken(JavadocParser.LEADING_ASTERISK, i); 8304 } 8305 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8306 public TerminalNode WS(int i) { 8307 return getToken(JavadocParser.WS, i); 8308 } 8309 public HtmlTagOpenContext(ParserRuleContext parent, int invokingState) { 8310 super(parent, invokingState); 8311 } 8312 @Override public int getRuleIndex() { return RULE_htmlTagOpen; } 8313 @Override 8314 public void enterRule(ParseTreeListener listener) { 8315 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagOpen(this); 8316 } 8317 @Override 8318 public void exitRule(ParseTreeListener listener) { 8319 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagOpen(this); 8320 } 8321 @Override 8322 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8323 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagOpen(this); 8324 else return visitor.visitChildren(this); 8325 } 8326 } 8327 8328 public final HtmlTagOpenContext htmlTagOpen() throws RecognitionException { 8329 HtmlTagOpenContext _localctx = new HtmlTagOpenContext(_ctx, getState()); 8330 enterRule(_localctx, 72, RULE_htmlTagOpen); 8331 int _la; 8332 try { 8333 enterOuterAlt(_localctx, 1); 8334 { 8335 setState(996); 8336 match(OPEN); 8337 setState(997); 8338 match(HTML_HTML_TAG_NAME); 8339 setState(1004); 8340 _errHandler.sync(this); 8341 _la = _input.LA(1); 8342 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 8343 { 8344 setState(1002); 8345 switch (_input.LA(1)) { 8346 case HTML_TAG_NAME: 8347 { 8348 setState(998); 8349 attribute(); 8350 } 8351 break; 8352 case NEWLINE: 8353 { 8354 setState(999); 8355 match(NEWLINE); 8356 } 8357 break; 8358 case LEADING_ASTERISK: 8359 { 8360 setState(1000); 8361 match(LEADING_ASTERISK); 8362 } 8363 break; 8364 case WS: 8365 { 8366 setState(1001); 8367 match(WS); 8368 } 8369 break; 8370 default: 8371 throw new NoViableAltException(this); 8372 } 8373 } 8374 setState(1006); 8375 _errHandler.sync(this); 8376 _la = _input.LA(1); 8377 } 8378 setState(1007); 8379 match(CLOSE); 8380 } 8381 } 8382 catch (RecognitionException re) { 8383 _localctx.exception = re; 8384 _errHandler.reportError(this, re); 8385 _errHandler.recover(this, re); 8386 } 8387 finally { 8388 exitRule(); 8389 } 8390 return _localctx; 8391 } 8392 8393 public static class HtmlTagCloseContext extends ParserRuleContext { 8394 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8395 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 8396 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 8397 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8398 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8399 public TerminalNode NEWLINE(int i) { 8400 return getToken(JavadocParser.NEWLINE, i); 8401 } 8402 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8403 public TerminalNode LEADING_ASTERISK(int i) { 8404 return getToken(JavadocParser.LEADING_ASTERISK, i); 8405 } 8406 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8407 public TerminalNode WS(int i) { 8408 return getToken(JavadocParser.WS, i); 8409 } 8410 public HtmlTagCloseContext(ParserRuleContext parent, int invokingState) { 8411 super(parent, invokingState); 8412 } 8413 @Override public int getRuleIndex() { return RULE_htmlTagClose; } 8414 @Override 8415 public void enterRule(ParseTreeListener listener) { 8416 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlTagClose(this); 8417 } 8418 @Override 8419 public void exitRule(ParseTreeListener listener) { 8420 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlTagClose(this); 8421 } 8422 @Override 8423 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8424 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagClose(this); 8425 else return visitor.visitChildren(this); 8426 } 8427 } 8428 8429 public final HtmlTagCloseContext htmlTagClose() throws RecognitionException { 8430 HtmlTagCloseContext _localctx = new HtmlTagCloseContext(_ctx, getState()); 8431 enterRule(_localctx, 74, RULE_htmlTagClose); 8432 int _la; 8433 try { 8434 enterOuterAlt(_localctx, 1); 8435 { 8436 setState(1009); 8437 match(OPEN); 8438 setState(1010); 8439 match(SLASH); 8440 setState(1011); 8441 match(HTML_HTML_TAG_NAME); 8442 setState(1015); 8443 _errHandler.sync(this); 8444 _la = _input.LA(1); 8445 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 8446 { 8447 { 8448 setState(1012); 8449 _la = _input.LA(1); 8450 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 8451 _errHandler.recoverInline(this); 8452 } else { 8453 consume(); 8454 } 8455 } 8456 } 8457 setState(1017); 8458 _errHandler.sync(this); 8459 _la = _input.LA(1); 8460 } 8461 setState(1018); 8462 match(CLOSE); 8463 } 8464 } 8465 catch (RecognitionException re) { 8466 _localctx.exception = re; 8467 _errHandler.reportError(this, re); 8468 _errHandler.recover(this, re); 8469 } 8470 finally { 8471 exitRule(); 8472 } 8473 return _localctx; 8474 } 8475 8476 public static class HtmlContext extends ParserRuleContext { 8477 public HtmlTagOpenContext htmlTagOpen() { 8478 return getRuleContext(HtmlTagOpenContext.class,0); 8479 } 8480 public HtmlTagCloseContext htmlTagClose() { 8481 return getRuleContext(HtmlTagCloseContext.class,0); 8482 } 8483 public List<HtmlTagContext> htmlTag() { 8484 return getRuleContexts(HtmlTagContext.class); 8485 } 8486 public HtmlTagContext htmlTag(int i) { 8487 return getRuleContext(HtmlTagContext.class,i); 8488 } 8489 public List<SingletonTagContext> singletonTag() { 8490 return getRuleContexts(SingletonTagContext.class); 8491 } 8492 public SingletonTagContext singletonTag(int i) { 8493 return getRuleContext(SingletonTagContext.class,i); 8494 } 8495 public List<ParagraphContext> paragraph() { 8496 return getRuleContexts(ParagraphContext.class); 8497 } 8498 public ParagraphContext paragraph(int i) { 8499 return getRuleContext(ParagraphContext.class,i); 8500 } 8501 public List<LiContext> li() { 8502 return getRuleContexts(LiContext.class); 8503 } 8504 public LiContext li(int i) { 8505 return getRuleContext(LiContext.class,i); 8506 } 8507 public List<TrContext> tr() { 8508 return getRuleContexts(TrContext.class); 8509 } 8510 public TrContext tr(int i) { 8511 return getRuleContext(TrContext.class,i); 8512 } 8513 public List<TdContext> td() { 8514 return getRuleContexts(TdContext.class); 8515 } 8516 public TdContext td(int i) { 8517 return getRuleContext(TdContext.class,i); 8518 } 8519 public List<ThContext> th() { 8520 return getRuleContexts(ThContext.class); 8521 } 8522 public ThContext th(int i) { 8523 return getRuleContext(ThContext.class,i); 8524 } 8525 public List<BodyContext> body() { 8526 return getRuleContexts(BodyContext.class); 8527 } 8528 public BodyContext body(int i) { 8529 return getRuleContext(BodyContext.class,i); 8530 } 8531 public List<ColgroupContext> colgroup() { 8532 return getRuleContexts(ColgroupContext.class); 8533 } 8534 public ColgroupContext colgroup(int i) { 8535 return getRuleContext(ColgroupContext.class,i); 8536 } 8537 public List<DdContext> dd() { 8538 return getRuleContexts(DdContext.class); 8539 } 8540 public DdContext dd(int i) { 8541 return getRuleContext(DdContext.class,i); 8542 } 8543 public List<DtContext> dt() { 8544 return getRuleContexts(DtContext.class); 8545 } 8546 public DtContext dt(int i) { 8547 return getRuleContext(DtContext.class,i); 8548 } 8549 public List<HeadContext> head() { 8550 return getRuleContexts(HeadContext.class); 8551 } 8552 public HeadContext head(int i) { 8553 return getRuleContext(HeadContext.class,i); 8554 } 8555 public List<OptionContext> option() { 8556 return getRuleContexts(OptionContext.class); 8557 } 8558 public OptionContext option(int i) { 8559 return getRuleContext(OptionContext.class,i); 8560 } 8561 public List<TbodyContext> tbody() { 8562 return getRuleContexts(TbodyContext.class); 8563 } 8564 public TbodyContext tbody(int i) { 8565 return getRuleContext(TbodyContext.class,i); 8566 } 8567 public List<TheadContext> thead() { 8568 return getRuleContexts(TheadContext.class); 8569 } 8570 public TheadContext thead(int i) { 8571 return getRuleContext(TheadContext.class,i); 8572 } 8573 public List<TfootContext> tfoot() { 8574 return getRuleContexts(TfootContext.class); 8575 } 8576 public TfootContext tfoot(int i) { 8577 return getRuleContext(TfootContext.class,i); 8578 } 8579 public List<PTagOpenContext> pTagOpen() { 8580 return getRuleContexts(PTagOpenContext.class); 8581 } 8582 public PTagOpenContext pTagOpen(int i) { 8583 return getRuleContext(PTagOpenContext.class,i); 8584 } 8585 public List<LiTagOpenContext> liTagOpen() { 8586 return getRuleContexts(LiTagOpenContext.class); 8587 } 8588 public LiTagOpenContext liTagOpen(int i) { 8589 return getRuleContext(LiTagOpenContext.class,i); 8590 } 8591 public List<TrTagOpenContext> trTagOpen() { 8592 return getRuleContexts(TrTagOpenContext.class); 8593 } 8594 public TrTagOpenContext trTagOpen(int i) { 8595 return getRuleContext(TrTagOpenContext.class,i); 8596 } 8597 public List<TdTagOpenContext> tdTagOpen() { 8598 return getRuleContexts(TdTagOpenContext.class); 8599 } 8600 public TdTagOpenContext tdTagOpen(int i) { 8601 return getRuleContext(TdTagOpenContext.class,i); 8602 } 8603 public List<ThTagOpenContext> thTagOpen() { 8604 return getRuleContexts(ThTagOpenContext.class); 8605 } 8606 public ThTagOpenContext thTagOpen(int i) { 8607 return getRuleContext(ThTagOpenContext.class,i); 8608 } 8609 public List<BodyTagOpenContext> bodyTagOpen() { 8610 return getRuleContexts(BodyTagOpenContext.class); 8611 } 8612 public BodyTagOpenContext bodyTagOpen(int i) { 8613 return getRuleContext(BodyTagOpenContext.class,i); 8614 } 8615 public List<ColgroupTagOpenContext> colgroupTagOpen() { 8616 return getRuleContexts(ColgroupTagOpenContext.class); 8617 } 8618 public ColgroupTagOpenContext colgroupTagOpen(int i) { 8619 return getRuleContext(ColgroupTagOpenContext.class,i); 8620 } 8621 public List<DdTagOpenContext> ddTagOpen() { 8622 return getRuleContexts(DdTagOpenContext.class); 8623 } 8624 public DdTagOpenContext ddTagOpen(int i) { 8625 return getRuleContext(DdTagOpenContext.class,i); 8626 } 8627 public List<DtTagOpenContext> dtTagOpen() { 8628 return getRuleContexts(DtTagOpenContext.class); 8629 } 8630 public DtTagOpenContext dtTagOpen(int i) { 8631 return getRuleContext(DtTagOpenContext.class,i); 8632 } 8633 public List<HeadTagOpenContext> headTagOpen() { 8634 return getRuleContexts(HeadTagOpenContext.class); 8635 } 8636 public HeadTagOpenContext headTagOpen(int i) { 8637 return getRuleContext(HeadTagOpenContext.class,i); 8638 } 8639 public List<OptionTagOpenContext> optionTagOpen() { 8640 return getRuleContexts(OptionTagOpenContext.class); 8641 } 8642 public OptionTagOpenContext optionTagOpen(int i) { 8643 return getRuleContext(OptionTagOpenContext.class,i); 8644 } 8645 public List<TbodyTagOpenContext> tbodyTagOpen() { 8646 return getRuleContexts(TbodyTagOpenContext.class); 8647 } 8648 public TbodyTagOpenContext tbodyTagOpen(int i) { 8649 return getRuleContext(TbodyTagOpenContext.class,i); 8650 } 8651 public List<TheadTagOpenContext> theadTagOpen() { 8652 return getRuleContexts(TheadTagOpenContext.class); 8653 } 8654 public TheadTagOpenContext theadTagOpen(int i) { 8655 return getRuleContext(TheadTagOpenContext.class,i); 8656 } 8657 public List<TfootTagOpenContext> tfootTagOpen() { 8658 return getRuleContexts(TfootTagOpenContext.class); 8659 } 8660 public TfootTagOpenContext tfootTagOpen(int i) { 8661 return getRuleContext(TfootTagOpenContext.class,i); 8662 } 8663 public List<HtmlCommentContext> htmlComment() { 8664 return getRuleContexts(HtmlCommentContext.class); 8665 } 8666 public HtmlCommentContext htmlComment(int i) { 8667 return getRuleContext(HtmlCommentContext.class,i); 8668 } 8669 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 8670 public TerminalNode CDATA(int i) { 8671 return getToken(JavadocParser.CDATA, i); 8672 } 8673 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8674 public TerminalNode NEWLINE(int i) { 8675 return getToken(JavadocParser.NEWLINE, i); 8676 } 8677 public List<TextContext> text() { 8678 return getRuleContexts(TextContext.class); 8679 } 8680 public TextContext text(int i) { 8681 return getRuleContext(TextContext.class,i); 8682 } 8683 public List<JavadocInlineTagContext> javadocInlineTag() { 8684 return getRuleContexts(JavadocInlineTagContext.class); 8685 } 8686 public JavadocInlineTagContext javadocInlineTag(int i) { 8687 return getRuleContext(JavadocInlineTagContext.class,i); 8688 } 8689 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8690 public TerminalNode LEADING_ASTERISK(int i) { 8691 return getToken(JavadocParser.LEADING_ASTERISK, i); 8692 } 8693 public HtmlContext(ParserRuleContext parent, int invokingState) { 8694 super(parent, invokingState); 8695 } 8696 @Override public int getRuleIndex() { return RULE_html; } 8697 @Override 8698 public void enterRule(ParseTreeListener listener) { 8699 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtml(this); 8700 } 8701 @Override 8702 public void exitRule(ParseTreeListener listener) { 8703 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtml(this); 8704 } 8705 @Override 8706 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 8707 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtml(this); 8708 else return visitor.visitChildren(this); 8709 } 8710 } 8711 8712 public final HtmlContext html() throws RecognitionException { 8713 HtmlContext _localctx = new HtmlContext(_ctx, getState()); 8714 enterRule(_localctx, 76, RULE_html); 8715 try { 8716 int _alt; 8717 enterOuterAlt(_localctx, 1); 8718 { 8719 setState(1020); 8720 htmlTagOpen(); 8721 setState(1060); 8722 _errHandler.sync(this); 8723 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 8724 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 8725 if ( _alt==1 ) { 8726 { 8727 setState(1058); 8728 _errHandler.sync(this); 8729 switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { 8730 case 1: 8731 { 8732 setState(1021); 8733 htmlTag(); 8734 } 8735 break; 8736 case 2: 8737 { 8738 setState(1022); 8739 singletonTag(); 8740 } 8741 break; 8742 case 3: 8743 { 8744 setState(1023); 8745 paragraph(); 8746 } 8747 break; 8748 case 4: 8749 { 8750 setState(1024); 8751 li(); 8752 } 8753 break; 8754 case 5: 8755 { 8756 setState(1025); 8757 tr(); 8758 } 8759 break; 8760 case 6: 8761 { 8762 setState(1026); 8763 td(); 8764 } 8765 break; 8766 case 7: 8767 { 8768 setState(1027); 8769 th(); 8770 } 8771 break; 8772 case 8: 8773 { 8774 setState(1028); 8775 body(); 8776 } 8777 break; 8778 case 9: 8779 { 8780 setState(1029); 8781 colgroup(); 8782 } 8783 break; 8784 case 10: 8785 { 8786 setState(1030); 8787 dd(); 8788 } 8789 break; 8790 case 11: 8791 { 8792 setState(1031); 8793 dt(); 8794 } 8795 break; 8796 case 12: 8797 { 8798 setState(1032); 8799 head(); 8800 } 8801 break; 8802 case 13: 8803 { 8804 setState(1033); 8805 option(); 8806 } 8807 break; 8808 case 14: 8809 { 8810 setState(1034); 8811 tbody(); 8812 } 8813 break; 8814 case 15: 8815 { 8816 setState(1035); 8817 thead(); 8818 } 8819 break; 8820 case 16: 8821 { 8822 setState(1036); 8823 tfoot(); 8824 } 8825 break; 8826 case 17: 8827 { 8828 setState(1037); 8829 pTagOpen(); 8830 } 8831 break; 8832 case 18: 8833 { 8834 setState(1038); 8835 liTagOpen(); 8836 } 8837 break; 8838 case 19: 8839 { 8840 setState(1039); 8841 trTagOpen(); 8842 } 8843 break; 8844 case 20: 8845 { 8846 setState(1040); 8847 tdTagOpen(); 8848 } 8849 break; 8850 case 21: 8851 { 8852 setState(1041); 8853 thTagOpen(); 8854 } 8855 break; 8856 case 22: 8857 { 8858 setState(1042); 8859 bodyTagOpen(); 8860 } 8861 break; 8862 case 23: 8863 { 8864 setState(1043); 8865 colgroupTagOpen(); 8866 } 8867 break; 8868 case 24: 8869 { 8870 setState(1044); 8871 ddTagOpen(); 8872 } 8873 break; 8874 case 25: 8875 { 8876 setState(1045); 8877 dtTagOpen(); 8878 } 8879 break; 8880 case 26: 8881 { 8882 setState(1046); 8883 headTagOpen(); 8884 } 8885 break; 8886 case 27: 8887 { 8888 setState(1047); 8889 optionTagOpen(); 8890 } 8891 break; 8892 case 28: 8893 { 8894 setState(1048); 8895 tbodyTagOpen(); 8896 } 8897 break; 8898 case 29: 8899 { 8900 setState(1049); 8901 theadTagOpen(); 8902 } 8903 break; 8904 case 30: 8905 { 8906 setState(1050); 8907 tfootTagOpen(); 8908 } 8909 break; 8910 case 31: 8911 { 8912 { 8913 setState(1051); 8914 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 8915 setState(1052); 8916 match(LEADING_ASTERISK); 8917 } 8918 } 8919 break; 8920 case 32: 8921 { 8922 setState(1053); 8923 htmlComment(); 8924 } 8925 break; 8926 case 33: 8927 { 8928 setState(1054); 8929 match(CDATA); 8930 } 8931 break; 8932 case 34: 8933 { 8934 setState(1055); 8935 match(NEWLINE); 8936 } 8937 break; 8938 case 35: 8939 { 8940 setState(1056); 8941 text(); 8942 } 8943 break; 8944 case 36: 8945 { 8946 setState(1057); 8947 javadocInlineTag(); 8948 } 8949 break; 8950 } 8951 } 8952 } 8953 setState(1062); 8954 _errHandler.sync(this); 8955 _alt = getInterpreter().adaptivePredict(_input,71,_ctx); 8956 } 8957 setState(1063); 8958 htmlTagClose(); 8959 } 8960 } 8961 catch (RecognitionException re) { 8962 _localctx.exception = re; 8963 _errHandler.reportError(this, re); 8964 _errHandler.recover(this, re); 8965 } 8966 finally { 8967 exitRule(); 8968 } 8969 return _localctx; 8970 } 8971 8972 public static class OptionTagOpenContext extends ParserRuleContext { 8973 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 8974 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 8975 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 8976 public List<AttributeContext> attribute() { 8977 return getRuleContexts(AttributeContext.class); 8978 } 8979 public AttributeContext attribute(int i) { 8980 return getRuleContext(AttributeContext.class,i); 8981 } 8982 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 8983 public TerminalNode NEWLINE(int i) { 8984 return getToken(JavadocParser.NEWLINE, i); 8985 } 8986 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 8987 public TerminalNode LEADING_ASTERISK(int i) { 8988 return getToken(JavadocParser.LEADING_ASTERISK, i); 8989 } 8990 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 8991 public TerminalNode WS(int i) { 8992 return getToken(JavadocParser.WS, i); 8993 } 8994 public OptionTagOpenContext(ParserRuleContext parent, int invokingState) { 8995 super(parent, invokingState); 8996 } 8997 @Override public int getRuleIndex() { return RULE_optionTagOpen; } 8998 @Override 8999 public void enterRule(ParseTreeListener listener) { 9000 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagOpen(this); 9001 } 9002 @Override 9003 public void exitRule(ParseTreeListener listener) { 9004 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagOpen(this); 9005 } 9006 @Override 9007 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9008 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagOpen(this); 9009 else return visitor.visitChildren(this); 9010 } 9011 } 9012 9013 public final OptionTagOpenContext optionTagOpen() throws RecognitionException { 9014 OptionTagOpenContext _localctx = new OptionTagOpenContext(_ctx, getState()); 9015 enterRule(_localctx, 78, RULE_optionTagOpen); 9016 int _la; 9017 try { 9018 enterOuterAlt(_localctx, 1); 9019 { 9020 setState(1065); 9021 match(OPEN); 9022 setState(1066); 9023 match(OPTION_HTML_TAG_NAME); 9024 setState(1073); 9025 _errHandler.sync(this); 9026 _la = _input.LA(1); 9027 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9028 { 9029 setState(1071); 9030 switch (_input.LA(1)) { 9031 case HTML_TAG_NAME: 9032 { 9033 setState(1067); 9034 attribute(); 9035 } 9036 break; 9037 case NEWLINE: 9038 { 9039 setState(1068); 9040 match(NEWLINE); 9041 } 9042 break; 9043 case LEADING_ASTERISK: 9044 { 9045 setState(1069); 9046 match(LEADING_ASTERISK); 9047 } 9048 break; 9049 case WS: 9050 { 9051 setState(1070); 9052 match(WS); 9053 } 9054 break; 9055 default: 9056 throw new NoViableAltException(this); 9057 } 9058 } 9059 setState(1075); 9060 _errHandler.sync(this); 9061 _la = _input.LA(1); 9062 } 9063 setState(1076); 9064 match(CLOSE); 9065 } 9066 } 9067 catch (RecognitionException re) { 9068 _localctx.exception = re; 9069 _errHandler.reportError(this, re); 9070 _errHandler.recover(this, re); 9071 } 9072 finally { 9073 exitRule(); 9074 } 9075 return _localctx; 9076 } 9077 9078 public static class OptionTagCloseContext extends ParserRuleContext { 9079 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9080 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9081 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 9082 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9083 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9084 public TerminalNode NEWLINE(int i) { 9085 return getToken(JavadocParser.NEWLINE, i); 9086 } 9087 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9088 public TerminalNode LEADING_ASTERISK(int i) { 9089 return getToken(JavadocParser.LEADING_ASTERISK, i); 9090 } 9091 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9092 public TerminalNode WS(int i) { 9093 return getToken(JavadocParser.WS, i); 9094 } 9095 public OptionTagCloseContext(ParserRuleContext parent, int invokingState) { 9096 super(parent, invokingState); 9097 } 9098 @Override public int getRuleIndex() { return RULE_optionTagClose; } 9099 @Override 9100 public void enterRule(ParseTreeListener listener) { 9101 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOptionTagClose(this); 9102 } 9103 @Override 9104 public void exitRule(ParseTreeListener listener) { 9105 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOptionTagClose(this); 9106 } 9107 @Override 9108 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9109 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagClose(this); 9110 else return visitor.visitChildren(this); 9111 } 9112 } 9113 9114 public final OptionTagCloseContext optionTagClose() throws RecognitionException { 9115 OptionTagCloseContext _localctx = new OptionTagCloseContext(_ctx, getState()); 9116 enterRule(_localctx, 80, RULE_optionTagClose); 9117 int _la; 9118 try { 9119 enterOuterAlt(_localctx, 1); 9120 { 9121 setState(1078); 9122 match(OPEN); 9123 setState(1079); 9124 match(SLASH); 9125 setState(1080); 9126 match(OPTION_HTML_TAG_NAME); 9127 setState(1084); 9128 _errHandler.sync(this); 9129 _la = _input.LA(1); 9130 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9131 { 9132 { 9133 setState(1081); 9134 _la = _input.LA(1); 9135 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9136 _errHandler.recoverInline(this); 9137 } else { 9138 consume(); 9139 } 9140 } 9141 } 9142 setState(1086); 9143 _errHandler.sync(this); 9144 _la = _input.LA(1); 9145 } 9146 setState(1087); 9147 match(CLOSE); 9148 } 9149 } 9150 catch (RecognitionException re) { 9151 _localctx.exception = re; 9152 _errHandler.reportError(this, re); 9153 _errHandler.recover(this, re); 9154 } 9155 finally { 9156 exitRule(); 9157 } 9158 return _localctx; 9159 } 9160 9161 public static class OptionContext extends ParserRuleContext { 9162 public OptionTagOpenContext optionTagOpen() { 9163 return getRuleContext(OptionTagOpenContext.class,0); 9164 } 9165 public OptionTagCloseContext optionTagClose() { 9166 return getRuleContext(OptionTagCloseContext.class,0); 9167 } 9168 public List<HtmlTagContext> htmlTag() { 9169 return getRuleContexts(HtmlTagContext.class); 9170 } 9171 public HtmlTagContext htmlTag(int i) { 9172 return getRuleContext(HtmlTagContext.class,i); 9173 } 9174 public List<SingletonTagContext> singletonTag() { 9175 return getRuleContexts(SingletonTagContext.class); 9176 } 9177 public SingletonTagContext singletonTag(int i) { 9178 return getRuleContext(SingletonTagContext.class,i); 9179 } 9180 public List<ParagraphContext> paragraph() { 9181 return getRuleContexts(ParagraphContext.class); 9182 } 9183 public ParagraphContext paragraph(int i) { 9184 return getRuleContext(ParagraphContext.class,i); 9185 } 9186 public List<LiContext> li() { 9187 return getRuleContexts(LiContext.class); 9188 } 9189 public LiContext li(int i) { 9190 return getRuleContext(LiContext.class,i); 9191 } 9192 public List<TrContext> tr() { 9193 return getRuleContexts(TrContext.class); 9194 } 9195 public TrContext tr(int i) { 9196 return getRuleContext(TrContext.class,i); 9197 } 9198 public List<TdContext> td() { 9199 return getRuleContexts(TdContext.class); 9200 } 9201 public TdContext td(int i) { 9202 return getRuleContext(TdContext.class,i); 9203 } 9204 public List<ThContext> th() { 9205 return getRuleContexts(ThContext.class); 9206 } 9207 public ThContext th(int i) { 9208 return getRuleContext(ThContext.class,i); 9209 } 9210 public List<BodyContext> body() { 9211 return getRuleContexts(BodyContext.class); 9212 } 9213 public BodyContext body(int i) { 9214 return getRuleContext(BodyContext.class,i); 9215 } 9216 public List<ColgroupContext> colgroup() { 9217 return getRuleContexts(ColgroupContext.class); 9218 } 9219 public ColgroupContext colgroup(int i) { 9220 return getRuleContext(ColgroupContext.class,i); 9221 } 9222 public List<DdContext> dd() { 9223 return getRuleContexts(DdContext.class); 9224 } 9225 public DdContext dd(int i) { 9226 return getRuleContext(DdContext.class,i); 9227 } 9228 public List<DtContext> dt() { 9229 return getRuleContexts(DtContext.class); 9230 } 9231 public DtContext dt(int i) { 9232 return getRuleContext(DtContext.class,i); 9233 } 9234 public List<HeadContext> head() { 9235 return getRuleContexts(HeadContext.class); 9236 } 9237 public HeadContext head(int i) { 9238 return getRuleContext(HeadContext.class,i); 9239 } 9240 public List<HtmlContext> html() { 9241 return getRuleContexts(HtmlContext.class); 9242 } 9243 public HtmlContext html(int i) { 9244 return getRuleContext(HtmlContext.class,i); 9245 } 9246 public List<TbodyContext> tbody() { 9247 return getRuleContexts(TbodyContext.class); 9248 } 9249 public TbodyContext tbody(int i) { 9250 return getRuleContext(TbodyContext.class,i); 9251 } 9252 public List<TheadContext> thead() { 9253 return getRuleContexts(TheadContext.class); 9254 } 9255 public TheadContext thead(int i) { 9256 return getRuleContext(TheadContext.class,i); 9257 } 9258 public List<TfootContext> tfoot() { 9259 return getRuleContexts(TfootContext.class); 9260 } 9261 public TfootContext tfoot(int i) { 9262 return getRuleContext(TfootContext.class,i); 9263 } 9264 public List<PTagOpenContext> pTagOpen() { 9265 return getRuleContexts(PTagOpenContext.class); 9266 } 9267 public PTagOpenContext pTagOpen(int i) { 9268 return getRuleContext(PTagOpenContext.class,i); 9269 } 9270 public List<LiTagOpenContext> liTagOpen() { 9271 return getRuleContexts(LiTagOpenContext.class); 9272 } 9273 public LiTagOpenContext liTagOpen(int i) { 9274 return getRuleContext(LiTagOpenContext.class,i); 9275 } 9276 public List<TrTagOpenContext> trTagOpen() { 9277 return getRuleContexts(TrTagOpenContext.class); 9278 } 9279 public TrTagOpenContext trTagOpen(int i) { 9280 return getRuleContext(TrTagOpenContext.class,i); 9281 } 9282 public List<TdTagOpenContext> tdTagOpen() { 9283 return getRuleContexts(TdTagOpenContext.class); 9284 } 9285 public TdTagOpenContext tdTagOpen(int i) { 9286 return getRuleContext(TdTagOpenContext.class,i); 9287 } 9288 public List<ThTagOpenContext> thTagOpen() { 9289 return getRuleContexts(ThTagOpenContext.class); 9290 } 9291 public ThTagOpenContext thTagOpen(int i) { 9292 return getRuleContext(ThTagOpenContext.class,i); 9293 } 9294 public List<BodyTagOpenContext> bodyTagOpen() { 9295 return getRuleContexts(BodyTagOpenContext.class); 9296 } 9297 public BodyTagOpenContext bodyTagOpen(int i) { 9298 return getRuleContext(BodyTagOpenContext.class,i); 9299 } 9300 public List<ColgroupTagOpenContext> colgroupTagOpen() { 9301 return getRuleContexts(ColgroupTagOpenContext.class); 9302 } 9303 public ColgroupTagOpenContext colgroupTagOpen(int i) { 9304 return getRuleContext(ColgroupTagOpenContext.class,i); 9305 } 9306 public List<DdTagOpenContext> ddTagOpen() { 9307 return getRuleContexts(DdTagOpenContext.class); 9308 } 9309 public DdTagOpenContext ddTagOpen(int i) { 9310 return getRuleContext(DdTagOpenContext.class,i); 9311 } 9312 public List<DtTagOpenContext> dtTagOpen() { 9313 return getRuleContexts(DtTagOpenContext.class); 9314 } 9315 public DtTagOpenContext dtTagOpen(int i) { 9316 return getRuleContext(DtTagOpenContext.class,i); 9317 } 9318 public List<HeadTagOpenContext> headTagOpen() { 9319 return getRuleContexts(HeadTagOpenContext.class); 9320 } 9321 public HeadTagOpenContext headTagOpen(int i) { 9322 return getRuleContext(HeadTagOpenContext.class,i); 9323 } 9324 public List<HtmlTagOpenContext> htmlTagOpen() { 9325 return getRuleContexts(HtmlTagOpenContext.class); 9326 } 9327 public HtmlTagOpenContext htmlTagOpen(int i) { 9328 return getRuleContext(HtmlTagOpenContext.class,i); 9329 } 9330 public List<TbodyTagOpenContext> tbodyTagOpen() { 9331 return getRuleContexts(TbodyTagOpenContext.class); 9332 } 9333 public TbodyTagOpenContext tbodyTagOpen(int i) { 9334 return getRuleContext(TbodyTagOpenContext.class,i); 9335 } 9336 public List<TheadTagOpenContext> theadTagOpen() { 9337 return getRuleContexts(TheadTagOpenContext.class); 9338 } 9339 public TheadTagOpenContext theadTagOpen(int i) { 9340 return getRuleContext(TheadTagOpenContext.class,i); 9341 } 9342 public List<TfootTagOpenContext> tfootTagOpen() { 9343 return getRuleContexts(TfootTagOpenContext.class); 9344 } 9345 public TfootTagOpenContext tfootTagOpen(int i) { 9346 return getRuleContext(TfootTagOpenContext.class,i); 9347 } 9348 public List<HtmlCommentContext> htmlComment() { 9349 return getRuleContexts(HtmlCommentContext.class); 9350 } 9351 public HtmlCommentContext htmlComment(int i) { 9352 return getRuleContext(HtmlCommentContext.class,i); 9353 } 9354 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 9355 public TerminalNode CDATA(int i) { 9356 return getToken(JavadocParser.CDATA, i); 9357 } 9358 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9359 public TerminalNode NEWLINE(int i) { 9360 return getToken(JavadocParser.NEWLINE, i); 9361 } 9362 public List<TextContext> text() { 9363 return getRuleContexts(TextContext.class); 9364 } 9365 public TextContext text(int i) { 9366 return getRuleContext(TextContext.class,i); 9367 } 9368 public List<JavadocInlineTagContext> javadocInlineTag() { 9369 return getRuleContexts(JavadocInlineTagContext.class); 9370 } 9371 public JavadocInlineTagContext javadocInlineTag(int i) { 9372 return getRuleContext(JavadocInlineTagContext.class,i); 9373 } 9374 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9375 public TerminalNode LEADING_ASTERISK(int i) { 9376 return getToken(JavadocParser.LEADING_ASTERISK, i); 9377 } 9378 public OptionContext(ParserRuleContext parent, int invokingState) { 9379 super(parent, invokingState); 9380 } 9381 @Override public int getRuleIndex() { return RULE_option; } 9382 @Override 9383 public void enterRule(ParseTreeListener listener) { 9384 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterOption(this); 9385 } 9386 @Override 9387 public void exitRule(ParseTreeListener listener) { 9388 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitOption(this); 9389 } 9390 @Override 9391 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9392 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOption(this); 9393 else return visitor.visitChildren(this); 9394 } 9395 } 9396 9397 public final OptionContext option() throws RecognitionException { 9398 OptionContext _localctx = new OptionContext(_ctx, getState()); 9399 enterRule(_localctx, 82, RULE_option); 9400 try { 9401 int _alt; 9402 enterOuterAlt(_localctx, 1); 9403 { 9404 setState(1089); 9405 optionTagOpen(); 9406 setState(1129); 9407 _errHandler.sync(this); 9408 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 9409 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 9410 if ( _alt==1 ) { 9411 { 9412 setState(1127); 9413 _errHandler.sync(this); 9414 switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { 9415 case 1: 9416 { 9417 setState(1090); 9418 htmlTag(); 9419 } 9420 break; 9421 case 2: 9422 { 9423 setState(1091); 9424 singletonTag(); 9425 } 9426 break; 9427 case 3: 9428 { 9429 setState(1092); 9430 paragraph(); 9431 } 9432 break; 9433 case 4: 9434 { 9435 setState(1093); 9436 li(); 9437 } 9438 break; 9439 case 5: 9440 { 9441 setState(1094); 9442 tr(); 9443 } 9444 break; 9445 case 6: 9446 { 9447 setState(1095); 9448 td(); 9449 } 9450 break; 9451 case 7: 9452 { 9453 setState(1096); 9454 th(); 9455 } 9456 break; 9457 case 8: 9458 { 9459 setState(1097); 9460 body(); 9461 } 9462 break; 9463 case 9: 9464 { 9465 setState(1098); 9466 colgroup(); 9467 } 9468 break; 9469 case 10: 9470 { 9471 setState(1099); 9472 dd(); 9473 } 9474 break; 9475 case 11: 9476 { 9477 setState(1100); 9478 dt(); 9479 } 9480 break; 9481 case 12: 9482 { 9483 setState(1101); 9484 head(); 9485 } 9486 break; 9487 case 13: 9488 { 9489 setState(1102); 9490 html(); 9491 } 9492 break; 9493 case 14: 9494 { 9495 setState(1103); 9496 tbody(); 9497 } 9498 break; 9499 case 15: 9500 { 9501 setState(1104); 9502 thead(); 9503 } 9504 break; 9505 case 16: 9506 { 9507 setState(1105); 9508 tfoot(); 9509 } 9510 break; 9511 case 17: 9512 { 9513 setState(1106); 9514 pTagOpen(); 9515 } 9516 break; 9517 case 18: 9518 { 9519 setState(1107); 9520 liTagOpen(); 9521 } 9522 break; 9523 case 19: 9524 { 9525 setState(1108); 9526 trTagOpen(); 9527 } 9528 break; 9529 case 20: 9530 { 9531 setState(1109); 9532 tdTagOpen(); 9533 } 9534 break; 9535 case 21: 9536 { 9537 setState(1110); 9538 thTagOpen(); 9539 } 9540 break; 9541 case 22: 9542 { 9543 setState(1111); 9544 bodyTagOpen(); 9545 } 9546 break; 9547 case 23: 9548 { 9549 setState(1112); 9550 colgroupTagOpen(); 9551 } 9552 break; 9553 case 24: 9554 { 9555 setState(1113); 9556 ddTagOpen(); 9557 } 9558 break; 9559 case 25: 9560 { 9561 setState(1114); 9562 dtTagOpen(); 9563 } 9564 break; 9565 case 26: 9566 { 9567 setState(1115); 9568 headTagOpen(); 9569 } 9570 break; 9571 case 27: 9572 { 9573 setState(1116); 9574 htmlTagOpen(); 9575 } 9576 break; 9577 case 28: 9578 { 9579 setState(1117); 9580 tbodyTagOpen(); 9581 } 9582 break; 9583 case 29: 9584 { 9585 setState(1118); 9586 theadTagOpen(); 9587 } 9588 break; 9589 case 30: 9590 { 9591 setState(1119); 9592 tfootTagOpen(); 9593 } 9594 break; 9595 case 31: 9596 { 9597 { 9598 setState(1120); 9599 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 9600 setState(1121); 9601 match(LEADING_ASTERISK); 9602 } 9603 } 9604 break; 9605 case 32: 9606 { 9607 setState(1122); 9608 htmlComment(); 9609 } 9610 break; 9611 case 33: 9612 { 9613 setState(1123); 9614 match(CDATA); 9615 } 9616 break; 9617 case 34: 9618 { 9619 setState(1124); 9620 match(NEWLINE); 9621 } 9622 break; 9623 case 35: 9624 { 9625 setState(1125); 9626 text(); 9627 } 9628 break; 9629 case 36: 9630 { 9631 setState(1126); 9632 javadocInlineTag(); 9633 } 9634 break; 9635 } 9636 } 9637 } 9638 setState(1131); 9639 _errHandler.sync(this); 9640 _alt = getInterpreter().adaptivePredict(_input,76,_ctx); 9641 } 9642 setState(1132); 9643 optionTagClose(); 9644 } 9645 } 9646 catch (RecognitionException re) { 9647 _localctx.exception = re; 9648 _errHandler.reportError(this, re); 9649 _errHandler.recover(this, re); 9650 } 9651 finally { 9652 exitRule(); 9653 } 9654 return _localctx; 9655 } 9656 9657 public static class TbodyTagOpenContext extends ParserRuleContext { 9658 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9659 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9660 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9661 public List<AttributeContext> attribute() { 9662 return getRuleContexts(AttributeContext.class); 9663 } 9664 public AttributeContext attribute(int i) { 9665 return getRuleContext(AttributeContext.class,i); 9666 } 9667 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9668 public TerminalNode NEWLINE(int i) { 9669 return getToken(JavadocParser.NEWLINE, i); 9670 } 9671 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9672 public TerminalNode LEADING_ASTERISK(int i) { 9673 return getToken(JavadocParser.LEADING_ASTERISK, i); 9674 } 9675 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9676 public TerminalNode WS(int i) { 9677 return getToken(JavadocParser.WS, i); 9678 } 9679 public TbodyTagOpenContext(ParserRuleContext parent, int invokingState) { 9680 super(parent, invokingState); 9681 } 9682 @Override public int getRuleIndex() { return RULE_tbodyTagOpen; } 9683 @Override 9684 public void enterRule(ParseTreeListener listener) { 9685 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagOpen(this); 9686 } 9687 @Override 9688 public void exitRule(ParseTreeListener listener) { 9689 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagOpen(this); 9690 } 9691 @Override 9692 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9693 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagOpen(this); 9694 else return visitor.visitChildren(this); 9695 } 9696 } 9697 9698 public final TbodyTagOpenContext tbodyTagOpen() throws RecognitionException { 9699 TbodyTagOpenContext _localctx = new TbodyTagOpenContext(_ctx, getState()); 9700 enterRule(_localctx, 84, RULE_tbodyTagOpen); 9701 int _la; 9702 try { 9703 enterOuterAlt(_localctx, 1); 9704 { 9705 setState(1134); 9706 match(OPEN); 9707 setState(1135); 9708 match(TBODY_HTML_TAG_NAME); 9709 setState(1142); 9710 _errHandler.sync(this); 9711 _la = _input.LA(1); 9712 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 9713 { 9714 setState(1140); 9715 switch (_input.LA(1)) { 9716 case HTML_TAG_NAME: 9717 { 9718 setState(1136); 9719 attribute(); 9720 } 9721 break; 9722 case NEWLINE: 9723 { 9724 setState(1137); 9725 match(NEWLINE); 9726 } 9727 break; 9728 case LEADING_ASTERISK: 9729 { 9730 setState(1138); 9731 match(LEADING_ASTERISK); 9732 } 9733 break; 9734 case WS: 9735 { 9736 setState(1139); 9737 match(WS); 9738 } 9739 break; 9740 default: 9741 throw new NoViableAltException(this); 9742 } 9743 } 9744 setState(1144); 9745 _errHandler.sync(this); 9746 _la = _input.LA(1); 9747 } 9748 setState(1145); 9749 match(CLOSE); 9750 } 9751 } 9752 catch (RecognitionException re) { 9753 _localctx.exception = re; 9754 _errHandler.reportError(this, re); 9755 _errHandler.recover(this, re); 9756 } 9757 finally { 9758 exitRule(); 9759 } 9760 return _localctx; 9761 } 9762 9763 public static class TbodyTagCloseContext extends ParserRuleContext { 9764 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 9765 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 9766 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 9767 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 9768 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 9769 public TerminalNode NEWLINE(int i) { 9770 return getToken(JavadocParser.NEWLINE, i); 9771 } 9772 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 9773 public TerminalNode LEADING_ASTERISK(int i) { 9774 return getToken(JavadocParser.LEADING_ASTERISK, i); 9775 } 9776 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 9777 public TerminalNode WS(int i) { 9778 return getToken(JavadocParser.WS, i); 9779 } 9780 public TbodyTagCloseContext(ParserRuleContext parent, int invokingState) { 9781 super(parent, invokingState); 9782 } 9783 @Override public int getRuleIndex() { return RULE_tbodyTagClose; } 9784 @Override 9785 public void enterRule(ParseTreeListener listener) { 9786 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbodyTagClose(this); 9787 } 9788 @Override 9789 public void exitRule(ParseTreeListener listener) { 9790 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbodyTagClose(this); 9791 } 9792 @Override 9793 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 9794 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagClose(this); 9795 else return visitor.visitChildren(this); 9796 } 9797 } 9798 9799 public final TbodyTagCloseContext tbodyTagClose() throws RecognitionException { 9800 TbodyTagCloseContext _localctx = new TbodyTagCloseContext(_ctx, getState()); 9801 enterRule(_localctx, 86, RULE_tbodyTagClose); 9802 int _la; 9803 try { 9804 enterOuterAlt(_localctx, 1); 9805 { 9806 setState(1147); 9807 match(OPEN); 9808 setState(1148); 9809 match(SLASH); 9810 setState(1149); 9811 match(TBODY_HTML_TAG_NAME); 9812 setState(1153); 9813 _errHandler.sync(this); 9814 _la = _input.LA(1); 9815 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 9816 { 9817 { 9818 setState(1150); 9819 _la = _input.LA(1); 9820 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 9821 _errHandler.recoverInline(this); 9822 } else { 9823 consume(); 9824 } 9825 } 9826 } 9827 setState(1155); 9828 _errHandler.sync(this); 9829 _la = _input.LA(1); 9830 } 9831 setState(1156); 9832 match(CLOSE); 9833 } 9834 } 9835 catch (RecognitionException re) { 9836 _localctx.exception = re; 9837 _errHandler.reportError(this, re); 9838 _errHandler.recover(this, re); 9839 } 9840 finally { 9841 exitRule(); 9842 } 9843 return _localctx; 9844 } 9845 9846 public static class TbodyContext extends ParserRuleContext { 9847 public TbodyTagOpenContext tbodyTagOpen() { 9848 return getRuleContext(TbodyTagOpenContext.class,0); 9849 } 9850 public TbodyTagCloseContext tbodyTagClose() { 9851 return getRuleContext(TbodyTagCloseContext.class,0); 9852 } 9853 public List<HtmlTagContext> htmlTag() { 9854 return getRuleContexts(HtmlTagContext.class); 9855 } 9856 public HtmlTagContext htmlTag(int i) { 9857 return getRuleContext(HtmlTagContext.class,i); 9858 } 9859 public List<SingletonTagContext> singletonTag() { 9860 return getRuleContexts(SingletonTagContext.class); 9861 } 9862 public SingletonTagContext singletonTag(int i) { 9863 return getRuleContext(SingletonTagContext.class,i); 9864 } 9865 public List<ParagraphContext> paragraph() { 9866 return getRuleContexts(ParagraphContext.class); 9867 } 9868 public ParagraphContext paragraph(int i) { 9869 return getRuleContext(ParagraphContext.class,i); 9870 } 9871 public List<LiContext> li() { 9872 return getRuleContexts(LiContext.class); 9873 } 9874 public LiContext li(int i) { 9875 return getRuleContext(LiContext.class,i); 9876 } 9877 public List<TrContext> tr() { 9878 return getRuleContexts(TrContext.class); 9879 } 9880 public TrContext tr(int i) { 9881 return getRuleContext(TrContext.class,i); 9882 } 9883 public List<TdContext> td() { 9884 return getRuleContexts(TdContext.class); 9885 } 9886 public TdContext td(int i) { 9887 return getRuleContext(TdContext.class,i); 9888 } 9889 public List<ThContext> th() { 9890 return getRuleContexts(ThContext.class); 9891 } 9892 public ThContext th(int i) { 9893 return getRuleContext(ThContext.class,i); 9894 } 9895 public List<BodyContext> body() { 9896 return getRuleContexts(BodyContext.class); 9897 } 9898 public BodyContext body(int i) { 9899 return getRuleContext(BodyContext.class,i); 9900 } 9901 public List<ColgroupContext> colgroup() { 9902 return getRuleContexts(ColgroupContext.class); 9903 } 9904 public ColgroupContext colgroup(int i) { 9905 return getRuleContext(ColgroupContext.class,i); 9906 } 9907 public List<DdContext> dd() { 9908 return getRuleContexts(DdContext.class); 9909 } 9910 public DdContext dd(int i) { 9911 return getRuleContext(DdContext.class,i); 9912 } 9913 public List<DtContext> dt() { 9914 return getRuleContexts(DtContext.class); 9915 } 9916 public DtContext dt(int i) { 9917 return getRuleContext(DtContext.class,i); 9918 } 9919 public List<HeadContext> head() { 9920 return getRuleContexts(HeadContext.class); 9921 } 9922 public HeadContext head(int i) { 9923 return getRuleContext(HeadContext.class,i); 9924 } 9925 public List<HtmlContext> html() { 9926 return getRuleContexts(HtmlContext.class); 9927 } 9928 public HtmlContext html(int i) { 9929 return getRuleContext(HtmlContext.class,i); 9930 } 9931 public List<OptionContext> option() { 9932 return getRuleContexts(OptionContext.class); 9933 } 9934 public OptionContext option(int i) { 9935 return getRuleContext(OptionContext.class,i); 9936 } 9937 public List<TheadContext> thead() { 9938 return getRuleContexts(TheadContext.class); 9939 } 9940 public TheadContext thead(int i) { 9941 return getRuleContext(TheadContext.class,i); 9942 } 9943 public List<TfootContext> tfoot() { 9944 return getRuleContexts(TfootContext.class); 9945 } 9946 public TfootContext tfoot(int i) { 9947 return getRuleContext(TfootContext.class,i); 9948 } 9949 public List<PTagOpenContext> pTagOpen() { 9950 return getRuleContexts(PTagOpenContext.class); 9951 } 9952 public PTagOpenContext pTagOpen(int i) { 9953 return getRuleContext(PTagOpenContext.class,i); 9954 } 9955 public List<LiTagOpenContext> liTagOpen() { 9956 return getRuleContexts(LiTagOpenContext.class); 9957 } 9958 public LiTagOpenContext liTagOpen(int i) { 9959 return getRuleContext(LiTagOpenContext.class,i); 9960 } 9961 public List<TrTagOpenContext> trTagOpen() { 9962 return getRuleContexts(TrTagOpenContext.class); 9963 } 9964 public TrTagOpenContext trTagOpen(int i) { 9965 return getRuleContext(TrTagOpenContext.class,i); 9966 } 9967 public List<TdTagOpenContext> tdTagOpen() { 9968 return getRuleContexts(TdTagOpenContext.class); 9969 } 9970 public TdTagOpenContext tdTagOpen(int i) { 9971 return getRuleContext(TdTagOpenContext.class,i); 9972 } 9973 public List<ThTagOpenContext> thTagOpen() { 9974 return getRuleContexts(ThTagOpenContext.class); 9975 } 9976 public ThTagOpenContext thTagOpen(int i) { 9977 return getRuleContext(ThTagOpenContext.class,i); 9978 } 9979 public List<BodyTagOpenContext> bodyTagOpen() { 9980 return getRuleContexts(BodyTagOpenContext.class); 9981 } 9982 public BodyTagOpenContext bodyTagOpen(int i) { 9983 return getRuleContext(BodyTagOpenContext.class,i); 9984 } 9985 public List<ColgroupTagOpenContext> colgroupTagOpen() { 9986 return getRuleContexts(ColgroupTagOpenContext.class); 9987 } 9988 public ColgroupTagOpenContext colgroupTagOpen(int i) { 9989 return getRuleContext(ColgroupTagOpenContext.class,i); 9990 } 9991 public List<DdTagOpenContext> ddTagOpen() { 9992 return getRuleContexts(DdTagOpenContext.class); 9993 } 9994 public DdTagOpenContext ddTagOpen(int i) { 9995 return getRuleContext(DdTagOpenContext.class,i); 9996 } 9997 public List<DtTagOpenContext> dtTagOpen() { 9998 return getRuleContexts(DtTagOpenContext.class); 9999 } 10000 public DtTagOpenContext dtTagOpen(int i) { 10001 return getRuleContext(DtTagOpenContext.class,i); 10002 } 10003 public List<HeadTagOpenContext> headTagOpen() { 10004 return getRuleContexts(HeadTagOpenContext.class); 10005 } 10006 public HeadTagOpenContext headTagOpen(int i) { 10007 return getRuleContext(HeadTagOpenContext.class,i); 10008 } 10009 public List<HtmlTagOpenContext> htmlTagOpen() { 10010 return getRuleContexts(HtmlTagOpenContext.class); 10011 } 10012 public HtmlTagOpenContext htmlTagOpen(int i) { 10013 return getRuleContext(HtmlTagOpenContext.class,i); 10014 } 10015 public List<OptionTagOpenContext> optionTagOpen() { 10016 return getRuleContexts(OptionTagOpenContext.class); 10017 } 10018 public OptionTagOpenContext optionTagOpen(int i) { 10019 return getRuleContext(OptionTagOpenContext.class,i); 10020 } 10021 public List<TheadTagOpenContext> theadTagOpen() { 10022 return getRuleContexts(TheadTagOpenContext.class); 10023 } 10024 public TheadTagOpenContext theadTagOpen(int i) { 10025 return getRuleContext(TheadTagOpenContext.class,i); 10026 } 10027 public List<TfootTagOpenContext> tfootTagOpen() { 10028 return getRuleContexts(TfootTagOpenContext.class); 10029 } 10030 public TfootTagOpenContext tfootTagOpen(int i) { 10031 return getRuleContext(TfootTagOpenContext.class,i); 10032 } 10033 public List<HtmlCommentContext> htmlComment() { 10034 return getRuleContexts(HtmlCommentContext.class); 10035 } 10036 public HtmlCommentContext htmlComment(int i) { 10037 return getRuleContext(HtmlCommentContext.class,i); 10038 } 10039 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10040 public TerminalNode CDATA(int i) { 10041 return getToken(JavadocParser.CDATA, i); 10042 } 10043 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10044 public TerminalNode NEWLINE(int i) { 10045 return getToken(JavadocParser.NEWLINE, i); 10046 } 10047 public List<TextContext> text() { 10048 return getRuleContexts(TextContext.class); 10049 } 10050 public TextContext text(int i) { 10051 return getRuleContext(TextContext.class,i); 10052 } 10053 public List<JavadocInlineTagContext> javadocInlineTag() { 10054 return getRuleContexts(JavadocInlineTagContext.class); 10055 } 10056 public JavadocInlineTagContext javadocInlineTag(int i) { 10057 return getRuleContext(JavadocInlineTagContext.class,i); 10058 } 10059 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10060 public TerminalNode LEADING_ASTERISK(int i) { 10061 return getToken(JavadocParser.LEADING_ASTERISK, i); 10062 } 10063 public TbodyContext(ParserRuleContext parent, int invokingState) { 10064 super(parent, invokingState); 10065 } 10066 @Override public int getRuleIndex() { return RULE_tbody; } 10067 @Override 10068 public void enterRule(ParseTreeListener listener) { 10069 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTbody(this); 10070 } 10071 @Override 10072 public void exitRule(ParseTreeListener listener) { 10073 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTbody(this); 10074 } 10075 @Override 10076 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10077 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbody(this); 10078 else return visitor.visitChildren(this); 10079 } 10080 } 10081 10082 public final TbodyContext tbody() throws RecognitionException { 10083 TbodyContext _localctx = new TbodyContext(_ctx, getState()); 10084 enterRule(_localctx, 88, RULE_tbody); 10085 try { 10086 int _alt; 10087 enterOuterAlt(_localctx, 1); 10088 { 10089 setState(1158); 10090 tbodyTagOpen(); 10091 setState(1198); 10092 _errHandler.sync(this); 10093 _alt = getInterpreter().adaptivePredict(_input,81,_ctx); 10094 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10095 if ( _alt==1 ) { 10096 { 10097 setState(1196); 10098 _errHandler.sync(this); 10099 switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) { 10100 case 1: 10101 { 10102 setState(1159); 10103 htmlTag(); 10104 } 10105 break; 10106 case 2: 10107 { 10108 setState(1160); 10109 singletonTag(); 10110 } 10111 break; 10112 case 3: 10113 { 10114 setState(1161); 10115 paragraph(); 10116 } 10117 break; 10118 case 4: 10119 { 10120 setState(1162); 10121 li(); 10122 } 10123 break; 10124 case 5: 10125 { 10126 setState(1163); 10127 tr(); 10128 } 10129 break; 10130 case 6: 10131 { 10132 setState(1164); 10133 td(); 10134 } 10135 break; 10136 case 7: 10137 { 10138 setState(1165); 10139 th(); 10140 } 10141 break; 10142 case 8: 10143 { 10144 setState(1166); 10145 body(); 10146 } 10147 break; 10148 case 9: 10149 { 10150 setState(1167); 10151 colgroup(); 10152 } 10153 break; 10154 case 10: 10155 { 10156 setState(1168); 10157 dd(); 10158 } 10159 break; 10160 case 11: 10161 { 10162 setState(1169); 10163 dt(); 10164 } 10165 break; 10166 case 12: 10167 { 10168 setState(1170); 10169 head(); 10170 } 10171 break; 10172 case 13: 10173 { 10174 setState(1171); 10175 html(); 10176 } 10177 break; 10178 case 14: 10179 { 10180 setState(1172); 10181 option(); 10182 } 10183 break; 10184 case 15: 10185 { 10186 setState(1173); 10187 thead(); 10188 } 10189 break; 10190 case 16: 10191 { 10192 setState(1174); 10193 tfoot(); 10194 } 10195 break; 10196 case 17: 10197 { 10198 setState(1175); 10199 pTagOpen(); 10200 } 10201 break; 10202 case 18: 10203 { 10204 setState(1176); 10205 liTagOpen(); 10206 } 10207 break; 10208 case 19: 10209 { 10210 setState(1177); 10211 trTagOpen(); 10212 } 10213 break; 10214 case 20: 10215 { 10216 setState(1178); 10217 tdTagOpen(); 10218 } 10219 break; 10220 case 21: 10221 { 10222 setState(1179); 10223 thTagOpen(); 10224 } 10225 break; 10226 case 22: 10227 { 10228 setState(1180); 10229 bodyTagOpen(); 10230 } 10231 break; 10232 case 23: 10233 { 10234 setState(1181); 10235 colgroupTagOpen(); 10236 } 10237 break; 10238 case 24: 10239 { 10240 setState(1182); 10241 ddTagOpen(); 10242 } 10243 break; 10244 case 25: 10245 { 10246 setState(1183); 10247 dtTagOpen(); 10248 } 10249 break; 10250 case 26: 10251 { 10252 setState(1184); 10253 headTagOpen(); 10254 } 10255 break; 10256 case 27: 10257 { 10258 setState(1185); 10259 htmlTagOpen(); 10260 } 10261 break; 10262 case 28: 10263 { 10264 setState(1186); 10265 optionTagOpen(); 10266 } 10267 break; 10268 case 29: 10269 { 10270 setState(1187); 10271 theadTagOpen(); 10272 } 10273 break; 10274 case 30: 10275 { 10276 setState(1188); 10277 tfootTagOpen(); 10278 } 10279 break; 10280 case 31: 10281 { 10282 { 10283 setState(1189); 10284 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10285 setState(1190); 10286 match(LEADING_ASTERISK); 10287 } 10288 } 10289 break; 10290 case 32: 10291 { 10292 setState(1191); 10293 htmlComment(); 10294 } 10295 break; 10296 case 33: 10297 { 10298 setState(1192); 10299 match(CDATA); 10300 } 10301 break; 10302 case 34: 10303 { 10304 setState(1193); 10305 match(NEWLINE); 10306 } 10307 break; 10308 case 35: 10309 { 10310 setState(1194); 10311 text(); 10312 } 10313 break; 10314 case 36: 10315 { 10316 setState(1195); 10317 javadocInlineTag(); 10318 } 10319 break; 10320 } 10321 } 10322 } 10323 setState(1200); 10324 _errHandler.sync(this); 10325 _alt = getInterpreter().adaptivePredict(_input,81,_ctx); 10326 } 10327 setState(1201); 10328 tbodyTagClose(); 10329 } 10330 } 10331 catch (RecognitionException re) { 10332 _localctx.exception = re; 10333 _errHandler.reportError(this, re); 10334 _errHandler.recover(this, re); 10335 } 10336 finally { 10337 exitRule(); 10338 } 10339 return _localctx; 10340 } 10341 10342 public static class TfootTagOpenContext extends ParserRuleContext { 10343 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10344 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 10345 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10346 public List<AttributeContext> attribute() { 10347 return getRuleContexts(AttributeContext.class); 10348 } 10349 public AttributeContext attribute(int i) { 10350 return getRuleContext(AttributeContext.class,i); 10351 } 10352 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10353 public TerminalNode NEWLINE(int i) { 10354 return getToken(JavadocParser.NEWLINE, i); 10355 } 10356 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10357 public TerminalNode LEADING_ASTERISK(int i) { 10358 return getToken(JavadocParser.LEADING_ASTERISK, i); 10359 } 10360 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10361 public TerminalNode WS(int i) { 10362 return getToken(JavadocParser.WS, i); 10363 } 10364 public TfootTagOpenContext(ParserRuleContext parent, int invokingState) { 10365 super(parent, invokingState); 10366 } 10367 @Override public int getRuleIndex() { return RULE_tfootTagOpen; } 10368 @Override 10369 public void enterRule(ParseTreeListener listener) { 10370 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagOpen(this); 10371 } 10372 @Override 10373 public void exitRule(ParseTreeListener listener) { 10374 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagOpen(this); 10375 } 10376 @Override 10377 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10378 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagOpen(this); 10379 else return visitor.visitChildren(this); 10380 } 10381 } 10382 10383 public final TfootTagOpenContext tfootTagOpen() throws RecognitionException { 10384 TfootTagOpenContext _localctx = new TfootTagOpenContext(_ctx, getState()); 10385 enterRule(_localctx, 90, RULE_tfootTagOpen); 10386 int _la; 10387 try { 10388 enterOuterAlt(_localctx, 1); 10389 { 10390 setState(1203); 10391 match(OPEN); 10392 setState(1204); 10393 match(TFOOT_HTML_TAG_NAME); 10394 setState(1211); 10395 _errHandler.sync(this); 10396 _la = _input.LA(1); 10397 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 10398 { 10399 setState(1209); 10400 switch (_input.LA(1)) { 10401 case HTML_TAG_NAME: 10402 { 10403 setState(1205); 10404 attribute(); 10405 } 10406 break; 10407 case NEWLINE: 10408 { 10409 setState(1206); 10410 match(NEWLINE); 10411 } 10412 break; 10413 case LEADING_ASTERISK: 10414 { 10415 setState(1207); 10416 match(LEADING_ASTERISK); 10417 } 10418 break; 10419 case WS: 10420 { 10421 setState(1208); 10422 match(WS); 10423 } 10424 break; 10425 default: 10426 throw new NoViableAltException(this); 10427 } 10428 } 10429 setState(1213); 10430 _errHandler.sync(this); 10431 _la = _input.LA(1); 10432 } 10433 setState(1214); 10434 match(CLOSE); 10435 } 10436 } 10437 catch (RecognitionException re) { 10438 _localctx.exception = re; 10439 _errHandler.reportError(this, re); 10440 _errHandler.recover(this, re); 10441 } 10442 finally { 10443 exitRule(); 10444 } 10445 return _localctx; 10446 } 10447 10448 public static class TfootTagCloseContext extends ParserRuleContext { 10449 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 10450 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 10451 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 10452 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 10453 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10454 public TerminalNode NEWLINE(int i) { 10455 return getToken(JavadocParser.NEWLINE, i); 10456 } 10457 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10458 public TerminalNode LEADING_ASTERISK(int i) { 10459 return getToken(JavadocParser.LEADING_ASTERISK, i); 10460 } 10461 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 10462 public TerminalNode WS(int i) { 10463 return getToken(JavadocParser.WS, i); 10464 } 10465 public TfootTagCloseContext(ParserRuleContext parent, int invokingState) { 10466 super(parent, invokingState); 10467 } 10468 @Override public int getRuleIndex() { return RULE_tfootTagClose; } 10469 @Override 10470 public void enterRule(ParseTreeListener listener) { 10471 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfootTagClose(this); 10472 } 10473 @Override 10474 public void exitRule(ParseTreeListener listener) { 10475 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfootTagClose(this); 10476 } 10477 @Override 10478 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10479 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagClose(this); 10480 else return visitor.visitChildren(this); 10481 } 10482 } 10483 10484 public final TfootTagCloseContext tfootTagClose() throws RecognitionException { 10485 TfootTagCloseContext _localctx = new TfootTagCloseContext(_ctx, getState()); 10486 enterRule(_localctx, 92, RULE_tfootTagClose); 10487 int _la; 10488 try { 10489 enterOuterAlt(_localctx, 1); 10490 { 10491 setState(1216); 10492 match(OPEN); 10493 setState(1217); 10494 match(SLASH); 10495 setState(1218); 10496 match(TFOOT_HTML_TAG_NAME); 10497 setState(1222); 10498 _errHandler.sync(this); 10499 _la = _input.LA(1); 10500 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 10501 { 10502 { 10503 setState(1219); 10504 _la = _input.LA(1); 10505 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 10506 _errHandler.recoverInline(this); 10507 } else { 10508 consume(); 10509 } 10510 } 10511 } 10512 setState(1224); 10513 _errHandler.sync(this); 10514 _la = _input.LA(1); 10515 } 10516 setState(1225); 10517 match(CLOSE); 10518 } 10519 } 10520 catch (RecognitionException re) { 10521 _localctx.exception = re; 10522 _errHandler.reportError(this, re); 10523 _errHandler.recover(this, re); 10524 } 10525 finally { 10526 exitRule(); 10527 } 10528 return _localctx; 10529 } 10530 10531 public static class TfootContext extends ParserRuleContext { 10532 public TfootTagOpenContext tfootTagOpen() { 10533 return getRuleContext(TfootTagOpenContext.class,0); 10534 } 10535 public TfootTagCloseContext tfootTagClose() { 10536 return getRuleContext(TfootTagCloseContext.class,0); 10537 } 10538 public List<HtmlTagContext> htmlTag() { 10539 return getRuleContexts(HtmlTagContext.class); 10540 } 10541 public HtmlTagContext htmlTag(int i) { 10542 return getRuleContext(HtmlTagContext.class,i); 10543 } 10544 public List<SingletonTagContext> singletonTag() { 10545 return getRuleContexts(SingletonTagContext.class); 10546 } 10547 public SingletonTagContext singletonTag(int i) { 10548 return getRuleContext(SingletonTagContext.class,i); 10549 } 10550 public List<ParagraphContext> paragraph() { 10551 return getRuleContexts(ParagraphContext.class); 10552 } 10553 public ParagraphContext paragraph(int i) { 10554 return getRuleContext(ParagraphContext.class,i); 10555 } 10556 public List<LiContext> li() { 10557 return getRuleContexts(LiContext.class); 10558 } 10559 public LiContext li(int i) { 10560 return getRuleContext(LiContext.class,i); 10561 } 10562 public List<TrContext> tr() { 10563 return getRuleContexts(TrContext.class); 10564 } 10565 public TrContext tr(int i) { 10566 return getRuleContext(TrContext.class,i); 10567 } 10568 public List<TdContext> td() { 10569 return getRuleContexts(TdContext.class); 10570 } 10571 public TdContext td(int i) { 10572 return getRuleContext(TdContext.class,i); 10573 } 10574 public List<ThContext> th() { 10575 return getRuleContexts(ThContext.class); 10576 } 10577 public ThContext th(int i) { 10578 return getRuleContext(ThContext.class,i); 10579 } 10580 public List<BodyContext> body() { 10581 return getRuleContexts(BodyContext.class); 10582 } 10583 public BodyContext body(int i) { 10584 return getRuleContext(BodyContext.class,i); 10585 } 10586 public List<ColgroupContext> colgroup() { 10587 return getRuleContexts(ColgroupContext.class); 10588 } 10589 public ColgroupContext colgroup(int i) { 10590 return getRuleContext(ColgroupContext.class,i); 10591 } 10592 public List<DdContext> dd() { 10593 return getRuleContexts(DdContext.class); 10594 } 10595 public DdContext dd(int i) { 10596 return getRuleContext(DdContext.class,i); 10597 } 10598 public List<DtContext> dt() { 10599 return getRuleContexts(DtContext.class); 10600 } 10601 public DtContext dt(int i) { 10602 return getRuleContext(DtContext.class,i); 10603 } 10604 public List<HeadContext> head() { 10605 return getRuleContexts(HeadContext.class); 10606 } 10607 public HeadContext head(int i) { 10608 return getRuleContext(HeadContext.class,i); 10609 } 10610 public List<HtmlContext> html() { 10611 return getRuleContexts(HtmlContext.class); 10612 } 10613 public HtmlContext html(int i) { 10614 return getRuleContext(HtmlContext.class,i); 10615 } 10616 public List<OptionContext> option() { 10617 return getRuleContexts(OptionContext.class); 10618 } 10619 public OptionContext option(int i) { 10620 return getRuleContext(OptionContext.class,i); 10621 } 10622 public List<TbodyContext> tbody() { 10623 return getRuleContexts(TbodyContext.class); 10624 } 10625 public TbodyContext tbody(int i) { 10626 return getRuleContext(TbodyContext.class,i); 10627 } 10628 public List<TheadContext> thead() { 10629 return getRuleContexts(TheadContext.class); 10630 } 10631 public TheadContext thead(int i) { 10632 return getRuleContext(TheadContext.class,i); 10633 } 10634 public List<PTagOpenContext> pTagOpen() { 10635 return getRuleContexts(PTagOpenContext.class); 10636 } 10637 public PTagOpenContext pTagOpen(int i) { 10638 return getRuleContext(PTagOpenContext.class,i); 10639 } 10640 public List<LiTagOpenContext> liTagOpen() { 10641 return getRuleContexts(LiTagOpenContext.class); 10642 } 10643 public LiTagOpenContext liTagOpen(int i) { 10644 return getRuleContext(LiTagOpenContext.class,i); 10645 } 10646 public List<TrTagOpenContext> trTagOpen() { 10647 return getRuleContexts(TrTagOpenContext.class); 10648 } 10649 public TrTagOpenContext trTagOpen(int i) { 10650 return getRuleContext(TrTagOpenContext.class,i); 10651 } 10652 public List<TdTagOpenContext> tdTagOpen() { 10653 return getRuleContexts(TdTagOpenContext.class); 10654 } 10655 public TdTagOpenContext tdTagOpen(int i) { 10656 return getRuleContext(TdTagOpenContext.class,i); 10657 } 10658 public List<ThTagOpenContext> thTagOpen() { 10659 return getRuleContexts(ThTagOpenContext.class); 10660 } 10661 public ThTagOpenContext thTagOpen(int i) { 10662 return getRuleContext(ThTagOpenContext.class,i); 10663 } 10664 public List<BodyTagOpenContext> bodyTagOpen() { 10665 return getRuleContexts(BodyTagOpenContext.class); 10666 } 10667 public BodyTagOpenContext bodyTagOpen(int i) { 10668 return getRuleContext(BodyTagOpenContext.class,i); 10669 } 10670 public List<ColgroupTagOpenContext> colgroupTagOpen() { 10671 return getRuleContexts(ColgroupTagOpenContext.class); 10672 } 10673 public ColgroupTagOpenContext colgroupTagOpen(int i) { 10674 return getRuleContext(ColgroupTagOpenContext.class,i); 10675 } 10676 public List<DdTagOpenContext> ddTagOpen() { 10677 return getRuleContexts(DdTagOpenContext.class); 10678 } 10679 public DdTagOpenContext ddTagOpen(int i) { 10680 return getRuleContext(DdTagOpenContext.class,i); 10681 } 10682 public List<DtTagOpenContext> dtTagOpen() { 10683 return getRuleContexts(DtTagOpenContext.class); 10684 } 10685 public DtTagOpenContext dtTagOpen(int i) { 10686 return getRuleContext(DtTagOpenContext.class,i); 10687 } 10688 public List<HeadTagOpenContext> headTagOpen() { 10689 return getRuleContexts(HeadTagOpenContext.class); 10690 } 10691 public HeadTagOpenContext headTagOpen(int i) { 10692 return getRuleContext(HeadTagOpenContext.class,i); 10693 } 10694 public List<HtmlTagOpenContext> htmlTagOpen() { 10695 return getRuleContexts(HtmlTagOpenContext.class); 10696 } 10697 public HtmlTagOpenContext htmlTagOpen(int i) { 10698 return getRuleContext(HtmlTagOpenContext.class,i); 10699 } 10700 public List<OptionTagOpenContext> optionTagOpen() { 10701 return getRuleContexts(OptionTagOpenContext.class); 10702 } 10703 public OptionTagOpenContext optionTagOpen(int i) { 10704 return getRuleContext(OptionTagOpenContext.class,i); 10705 } 10706 public List<TbodyTagOpenContext> tbodyTagOpen() { 10707 return getRuleContexts(TbodyTagOpenContext.class); 10708 } 10709 public TbodyTagOpenContext tbodyTagOpen(int i) { 10710 return getRuleContext(TbodyTagOpenContext.class,i); 10711 } 10712 public List<TheadTagOpenContext> theadTagOpen() { 10713 return getRuleContexts(TheadTagOpenContext.class); 10714 } 10715 public TheadTagOpenContext theadTagOpen(int i) { 10716 return getRuleContext(TheadTagOpenContext.class,i); 10717 } 10718 public List<HtmlCommentContext> htmlComment() { 10719 return getRuleContexts(HtmlCommentContext.class); 10720 } 10721 public HtmlCommentContext htmlComment(int i) { 10722 return getRuleContext(HtmlCommentContext.class,i); 10723 } 10724 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 10725 public TerminalNode CDATA(int i) { 10726 return getToken(JavadocParser.CDATA, i); 10727 } 10728 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 10729 public TerminalNode NEWLINE(int i) { 10730 return getToken(JavadocParser.NEWLINE, i); 10731 } 10732 public List<TextContext> text() { 10733 return getRuleContexts(TextContext.class); 10734 } 10735 public TextContext text(int i) { 10736 return getRuleContext(TextContext.class,i); 10737 } 10738 public List<JavadocInlineTagContext> javadocInlineTag() { 10739 return getRuleContexts(JavadocInlineTagContext.class); 10740 } 10741 public JavadocInlineTagContext javadocInlineTag(int i) { 10742 return getRuleContext(JavadocInlineTagContext.class,i); 10743 } 10744 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 10745 public TerminalNode LEADING_ASTERISK(int i) { 10746 return getToken(JavadocParser.LEADING_ASTERISK, i); 10747 } 10748 public TfootContext(ParserRuleContext parent, int invokingState) { 10749 super(parent, invokingState); 10750 } 10751 @Override public int getRuleIndex() { return RULE_tfoot; } 10752 @Override 10753 public void enterRule(ParseTreeListener listener) { 10754 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTfoot(this); 10755 } 10756 @Override 10757 public void exitRule(ParseTreeListener listener) { 10758 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTfoot(this); 10759 } 10760 @Override 10761 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 10762 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfoot(this); 10763 else return visitor.visitChildren(this); 10764 } 10765 } 10766 10767 public final TfootContext tfoot() throws RecognitionException { 10768 TfootContext _localctx = new TfootContext(_ctx, getState()); 10769 enterRule(_localctx, 94, RULE_tfoot); 10770 try { 10771 int _alt; 10772 enterOuterAlt(_localctx, 1); 10773 { 10774 setState(1227); 10775 tfootTagOpen(); 10776 setState(1267); 10777 _errHandler.sync(this); 10778 _alt = getInterpreter().adaptivePredict(_input,86,_ctx); 10779 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 10780 if ( _alt==1 ) { 10781 { 10782 setState(1265); 10783 _errHandler.sync(this); 10784 switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) { 10785 case 1: 10786 { 10787 setState(1228); 10788 htmlTag(); 10789 } 10790 break; 10791 case 2: 10792 { 10793 setState(1229); 10794 singletonTag(); 10795 } 10796 break; 10797 case 3: 10798 { 10799 setState(1230); 10800 paragraph(); 10801 } 10802 break; 10803 case 4: 10804 { 10805 setState(1231); 10806 li(); 10807 } 10808 break; 10809 case 5: 10810 { 10811 setState(1232); 10812 tr(); 10813 } 10814 break; 10815 case 6: 10816 { 10817 setState(1233); 10818 td(); 10819 } 10820 break; 10821 case 7: 10822 { 10823 setState(1234); 10824 th(); 10825 } 10826 break; 10827 case 8: 10828 { 10829 setState(1235); 10830 body(); 10831 } 10832 break; 10833 case 9: 10834 { 10835 setState(1236); 10836 colgroup(); 10837 } 10838 break; 10839 case 10: 10840 { 10841 setState(1237); 10842 dd(); 10843 } 10844 break; 10845 case 11: 10846 { 10847 setState(1238); 10848 dt(); 10849 } 10850 break; 10851 case 12: 10852 { 10853 setState(1239); 10854 head(); 10855 } 10856 break; 10857 case 13: 10858 { 10859 setState(1240); 10860 html(); 10861 } 10862 break; 10863 case 14: 10864 { 10865 setState(1241); 10866 option(); 10867 } 10868 break; 10869 case 15: 10870 { 10871 setState(1242); 10872 tbody(); 10873 } 10874 break; 10875 case 16: 10876 { 10877 setState(1243); 10878 thead(); 10879 } 10880 break; 10881 case 17: 10882 { 10883 setState(1244); 10884 pTagOpen(); 10885 } 10886 break; 10887 case 18: 10888 { 10889 setState(1245); 10890 liTagOpen(); 10891 } 10892 break; 10893 case 19: 10894 { 10895 setState(1246); 10896 trTagOpen(); 10897 } 10898 break; 10899 case 20: 10900 { 10901 setState(1247); 10902 tdTagOpen(); 10903 } 10904 break; 10905 case 21: 10906 { 10907 setState(1248); 10908 thTagOpen(); 10909 } 10910 break; 10911 case 22: 10912 { 10913 setState(1249); 10914 bodyTagOpen(); 10915 } 10916 break; 10917 case 23: 10918 { 10919 setState(1250); 10920 colgroupTagOpen(); 10921 } 10922 break; 10923 case 24: 10924 { 10925 setState(1251); 10926 ddTagOpen(); 10927 } 10928 break; 10929 case 25: 10930 { 10931 setState(1252); 10932 dtTagOpen(); 10933 } 10934 break; 10935 case 26: 10936 { 10937 setState(1253); 10938 headTagOpen(); 10939 } 10940 break; 10941 case 27: 10942 { 10943 setState(1254); 10944 htmlTagOpen(); 10945 } 10946 break; 10947 case 28: 10948 { 10949 setState(1255); 10950 optionTagOpen(); 10951 } 10952 break; 10953 case 29: 10954 { 10955 setState(1256); 10956 tbodyTagOpen(); 10957 } 10958 break; 10959 case 30: 10960 { 10961 setState(1257); 10962 theadTagOpen(); 10963 } 10964 break; 10965 case 31: 10966 { 10967 { 10968 setState(1258); 10969 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 10970 setState(1259); 10971 match(LEADING_ASTERISK); 10972 } 10973 } 10974 break; 10975 case 32: 10976 { 10977 setState(1260); 10978 htmlComment(); 10979 } 10980 break; 10981 case 33: 10982 { 10983 setState(1261); 10984 match(CDATA); 10985 } 10986 break; 10987 case 34: 10988 { 10989 setState(1262); 10990 match(NEWLINE); 10991 } 10992 break; 10993 case 35: 10994 { 10995 setState(1263); 10996 text(); 10997 } 10998 break; 10999 case 36: 11000 { 11001 setState(1264); 11002 javadocInlineTag(); 11003 } 11004 break; 11005 } 11006 } 11007 } 11008 setState(1269); 11009 _errHandler.sync(this); 11010 _alt = getInterpreter().adaptivePredict(_input,86,_ctx); 11011 } 11012 setState(1270); 11013 tfootTagClose(); 11014 } 11015 } 11016 catch (RecognitionException re) { 11017 _localctx.exception = re; 11018 _errHandler.reportError(this, re); 11019 _errHandler.recover(this, re); 11020 } 11021 finally { 11022 exitRule(); 11023 } 11024 return _localctx; 11025 } 11026 11027 public static class TheadTagOpenContext extends ParserRuleContext { 11028 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11029 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11030 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11031 public List<AttributeContext> attribute() { 11032 return getRuleContexts(AttributeContext.class); 11033 } 11034 public AttributeContext attribute(int i) { 11035 return getRuleContext(AttributeContext.class,i); 11036 } 11037 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11038 public TerminalNode NEWLINE(int i) { 11039 return getToken(JavadocParser.NEWLINE, i); 11040 } 11041 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11042 public TerminalNode LEADING_ASTERISK(int i) { 11043 return getToken(JavadocParser.LEADING_ASTERISK, i); 11044 } 11045 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11046 public TerminalNode WS(int i) { 11047 return getToken(JavadocParser.WS, i); 11048 } 11049 public TheadTagOpenContext(ParserRuleContext parent, int invokingState) { 11050 super(parent, invokingState); 11051 } 11052 @Override public int getRuleIndex() { return RULE_theadTagOpen; } 11053 @Override 11054 public void enterRule(ParseTreeListener listener) { 11055 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagOpen(this); 11056 } 11057 @Override 11058 public void exitRule(ParseTreeListener listener) { 11059 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagOpen(this); 11060 } 11061 @Override 11062 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11063 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagOpen(this); 11064 else return visitor.visitChildren(this); 11065 } 11066 } 11067 11068 public final TheadTagOpenContext theadTagOpen() throws RecognitionException { 11069 TheadTagOpenContext _localctx = new TheadTagOpenContext(_ctx, getState()); 11070 enterRule(_localctx, 96, RULE_theadTagOpen); 11071 int _la; 11072 try { 11073 enterOuterAlt(_localctx, 1); 11074 { 11075 setState(1272); 11076 match(OPEN); 11077 setState(1273); 11078 match(THEAD_HTML_TAG_NAME); 11079 setState(1280); 11080 _errHandler.sync(this); 11081 _la = _input.LA(1); 11082 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11083 { 11084 setState(1278); 11085 switch (_input.LA(1)) { 11086 case HTML_TAG_NAME: 11087 { 11088 setState(1274); 11089 attribute(); 11090 } 11091 break; 11092 case NEWLINE: 11093 { 11094 setState(1275); 11095 match(NEWLINE); 11096 } 11097 break; 11098 case LEADING_ASTERISK: 11099 { 11100 setState(1276); 11101 match(LEADING_ASTERISK); 11102 } 11103 break; 11104 case WS: 11105 { 11106 setState(1277); 11107 match(WS); 11108 } 11109 break; 11110 default: 11111 throw new NoViableAltException(this); 11112 } 11113 } 11114 setState(1282); 11115 _errHandler.sync(this); 11116 _la = _input.LA(1); 11117 } 11118 setState(1283); 11119 match(CLOSE); 11120 } 11121 } 11122 catch (RecognitionException re) { 11123 _localctx.exception = re; 11124 _errHandler.reportError(this, re); 11125 _errHandler.recover(this, re); 11126 } 11127 finally { 11128 exitRule(); 11129 } 11130 return _localctx; 11131 } 11132 11133 public static class TheadTagCloseContext extends ParserRuleContext { 11134 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11135 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 11136 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11137 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 11138 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11139 public TerminalNode NEWLINE(int i) { 11140 return getToken(JavadocParser.NEWLINE, i); 11141 } 11142 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11143 public TerminalNode LEADING_ASTERISK(int i) { 11144 return getToken(JavadocParser.LEADING_ASTERISK, i); 11145 } 11146 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11147 public TerminalNode WS(int i) { 11148 return getToken(JavadocParser.WS, i); 11149 } 11150 public TheadTagCloseContext(ParserRuleContext parent, int invokingState) { 11151 super(parent, invokingState); 11152 } 11153 @Override public int getRuleIndex() { return RULE_theadTagClose; } 11154 @Override 11155 public void enterRule(ParseTreeListener listener) { 11156 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterTheadTagClose(this); 11157 } 11158 @Override 11159 public void exitRule(ParseTreeListener listener) { 11160 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitTheadTagClose(this); 11161 } 11162 @Override 11163 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11164 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagClose(this); 11165 else return visitor.visitChildren(this); 11166 } 11167 } 11168 11169 public final TheadTagCloseContext theadTagClose() throws RecognitionException { 11170 TheadTagCloseContext _localctx = new TheadTagCloseContext(_ctx, getState()); 11171 enterRule(_localctx, 98, RULE_theadTagClose); 11172 int _la; 11173 try { 11174 enterOuterAlt(_localctx, 1); 11175 { 11176 setState(1285); 11177 match(OPEN); 11178 setState(1286); 11179 match(SLASH); 11180 setState(1287); 11181 match(THEAD_HTML_TAG_NAME); 11182 setState(1291); 11183 _errHandler.sync(this); 11184 _la = _input.LA(1); 11185 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 11186 { 11187 { 11188 setState(1288); 11189 _la = _input.LA(1); 11190 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 11191 _errHandler.recoverInline(this); 11192 } else { 11193 consume(); 11194 } 11195 } 11196 } 11197 setState(1293); 11198 _errHandler.sync(this); 11199 _la = _input.LA(1); 11200 } 11201 setState(1294); 11202 match(CLOSE); 11203 } 11204 } 11205 catch (RecognitionException re) { 11206 _localctx.exception = re; 11207 _errHandler.reportError(this, re); 11208 _errHandler.recover(this, re); 11209 } 11210 finally { 11211 exitRule(); 11212 } 11213 return _localctx; 11214 } 11215 11216 public static class TheadContext extends ParserRuleContext { 11217 public TheadTagOpenContext theadTagOpen() { 11218 return getRuleContext(TheadTagOpenContext.class,0); 11219 } 11220 public TheadTagCloseContext theadTagClose() { 11221 return getRuleContext(TheadTagCloseContext.class,0); 11222 } 11223 public List<HtmlTagContext> htmlTag() { 11224 return getRuleContexts(HtmlTagContext.class); 11225 } 11226 public HtmlTagContext htmlTag(int i) { 11227 return getRuleContext(HtmlTagContext.class,i); 11228 } 11229 public List<SingletonTagContext> singletonTag() { 11230 return getRuleContexts(SingletonTagContext.class); 11231 } 11232 public SingletonTagContext singletonTag(int i) { 11233 return getRuleContext(SingletonTagContext.class,i); 11234 } 11235 public List<ParagraphContext> paragraph() { 11236 return getRuleContexts(ParagraphContext.class); 11237 } 11238 public ParagraphContext paragraph(int i) { 11239 return getRuleContext(ParagraphContext.class,i); 11240 } 11241 public List<LiContext> li() { 11242 return getRuleContexts(LiContext.class); 11243 } 11244 public LiContext li(int i) { 11245 return getRuleContext(LiContext.class,i); 11246 } 11247 public List<TrContext> tr() { 11248 return getRuleContexts(TrContext.class); 11249 } 11250 public TrContext tr(int i) { 11251 return getRuleContext(TrContext.class,i); 11252 } 11253 public List<TdContext> td() { 11254 return getRuleContexts(TdContext.class); 11255 } 11256 public TdContext td(int i) { 11257 return getRuleContext(TdContext.class,i); 11258 } 11259 public List<ThContext> th() { 11260 return getRuleContexts(ThContext.class); 11261 } 11262 public ThContext th(int i) { 11263 return getRuleContext(ThContext.class,i); 11264 } 11265 public List<BodyContext> body() { 11266 return getRuleContexts(BodyContext.class); 11267 } 11268 public BodyContext body(int i) { 11269 return getRuleContext(BodyContext.class,i); 11270 } 11271 public List<ColgroupContext> colgroup() { 11272 return getRuleContexts(ColgroupContext.class); 11273 } 11274 public ColgroupContext colgroup(int i) { 11275 return getRuleContext(ColgroupContext.class,i); 11276 } 11277 public List<DdContext> dd() { 11278 return getRuleContexts(DdContext.class); 11279 } 11280 public DdContext dd(int i) { 11281 return getRuleContext(DdContext.class,i); 11282 } 11283 public List<DtContext> dt() { 11284 return getRuleContexts(DtContext.class); 11285 } 11286 public DtContext dt(int i) { 11287 return getRuleContext(DtContext.class,i); 11288 } 11289 public List<HeadContext> head() { 11290 return getRuleContexts(HeadContext.class); 11291 } 11292 public HeadContext head(int i) { 11293 return getRuleContext(HeadContext.class,i); 11294 } 11295 public List<HtmlContext> html() { 11296 return getRuleContexts(HtmlContext.class); 11297 } 11298 public HtmlContext html(int i) { 11299 return getRuleContext(HtmlContext.class,i); 11300 } 11301 public List<OptionContext> option() { 11302 return getRuleContexts(OptionContext.class); 11303 } 11304 public OptionContext option(int i) { 11305 return getRuleContext(OptionContext.class,i); 11306 } 11307 public List<TbodyContext> tbody() { 11308 return getRuleContexts(TbodyContext.class); 11309 } 11310 public TbodyContext tbody(int i) { 11311 return getRuleContext(TbodyContext.class,i); 11312 } 11313 public List<TfootContext> tfoot() { 11314 return getRuleContexts(TfootContext.class); 11315 } 11316 public TfootContext tfoot(int i) { 11317 return getRuleContext(TfootContext.class,i); 11318 } 11319 public List<PTagOpenContext> pTagOpen() { 11320 return getRuleContexts(PTagOpenContext.class); 11321 } 11322 public PTagOpenContext pTagOpen(int i) { 11323 return getRuleContext(PTagOpenContext.class,i); 11324 } 11325 public List<LiTagOpenContext> liTagOpen() { 11326 return getRuleContexts(LiTagOpenContext.class); 11327 } 11328 public LiTagOpenContext liTagOpen(int i) { 11329 return getRuleContext(LiTagOpenContext.class,i); 11330 } 11331 public List<TrTagOpenContext> trTagOpen() { 11332 return getRuleContexts(TrTagOpenContext.class); 11333 } 11334 public TrTagOpenContext trTagOpen(int i) { 11335 return getRuleContext(TrTagOpenContext.class,i); 11336 } 11337 public List<TdTagOpenContext> tdTagOpen() { 11338 return getRuleContexts(TdTagOpenContext.class); 11339 } 11340 public TdTagOpenContext tdTagOpen(int i) { 11341 return getRuleContext(TdTagOpenContext.class,i); 11342 } 11343 public List<ThTagOpenContext> thTagOpen() { 11344 return getRuleContexts(ThTagOpenContext.class); 11345 } 11346 public ThTagOpenContext thTagOpen(int i) { 11347 return getRuleContext(ThTagOpenContext.class,i); 11348 } 11349 public List<BodyTagOpenContext> bodyTagOpen() { 11350 return getRuleContexts(BodyTagOpenContext.class); 11351 } 11352 public BodyTagOpenContext bodyTagOpen(int i) { 11353 return getRuleContext(BodyTagOpenContext.class,i); 11354 } 11355 public List<ColgroupTagOpenContext> colgroupTagOpen() { 11356 return getRuleContexts(ColgroupTagOpenContext.class); 11357 } 11358 public ColgroupTagOpenContext colgroupTagOpen(int i) { 11359 return getRuleContext(ColgroupTagOpenContext.class,i); 11360 } 11361 public List<DdTagOpenContext> ddTagOpen() { 11362 return getRuleContexts(DdTagOpenContext.class); 11363 } 11364 public DdTagOpenContext ddTagOpen(int i) { 11365 return getRuleContext(DdTagOpenContext.class,i); 11366 } 11367 public List<DtTagOpenContext> dtTagOpen() { 11368 return getRuleContexts(DtTagOpenContext.class); 11369 } 11370 public DtTagOpenContext dtTagOpen(int i) { 11371 return getRuleContext(DtTagOpenContext.class,i); 11372 } 11373 public List<HeadTagOpenContext> headTagOpen() { 11374 return getRuleContexts(HeadTagOpenContext.class); 11375 } 11376 public HeadTagOpenContext headTagOpen(int i) { 11377 return getRuleContext(HeadTagOpenContext.class,i); 11378 } 11379 public List<HtmlTagOpenContext> htmlTagOpen() { 11380 return getRuleContexts(HtmlTagOpenContext.class); 11381 } 11382 public HtmlTagOpenContext htmlTagOpen(int i) { 11383 return getRuleContext(HtmlTagOpenContext.class,i); 11384 } 11385 public List<OptionTagOpenContext> optionTagOpen() { 11386 return getRuleContexts(OptionTagOpenContext.class); 11387 } 11388 public OptionTagOpenContext optionTagOpen(int i) { 11389 return getRuleContext(OptionTagOpenContext.class,i); 11390 } 11391 public List<TbodyTagOpenContext> tbodyTagOpen() { 11392 return getRuleContexts(TbodyTagOpenContext.class); 11393 } 11394 public TbodyTagOpenContext tbodyTagOpen(int i) { 11395 return getRuleContext(TbodyTagOpenContext.class,i); 11396 } 11397 public List<TfootTagOpenContext> tfootTagOpen() { 11398 return getRuleContexts(TfootTagOpenContext.class); 11399 } 11400 public TfootTagOpenContext tfootTagOpen(int i) { 11401 return getRuleContext(TfootTagOpenContext.class,i); 11402 } 11403 public List<HtmlCommentContext> htmlComment() { 11404 return getRuleContexts(HtmlCommentContext.class); 11405 } 11406 public HtmlCommentContext htmlComment(int i) { 11407 return getRuleContext(HtmlCommentContext.class,i); 11408 } 11409 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 11410 public TerminalNode CDATA(int i) { 11411 return getToken(JavadocParser.CDATA, i); 11412 } 11413 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11414 public TerminalNode NEWLINE(int i) { 11415 return getToken(JavadocParser.NEWLINE, i); 11416 } 11417 public List<TextContext> text() { 11418 return getRuleContexts(TextContext.class); 11419 } 11420 public TextContext text(int i) { 11421 return getRuleContext(TextContext.class,i); 11422 } 11423 public List<JavadocInlineTagContext> javadocInlineTag() { 11424 return getRuleContexts(JavadocInlineTagContext.class); 11425 } 11426 public JavadocInlineTagContext javadocInlineTag(int i) { 11427 return getRuleContext(JavadocInlineTagContext.class,i); 11428 } 11429 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11430 public TerminalNode LEADING_ASTERISK(int i) { 11431 return getToken(JavadocParser.LEADING_ASTERISK, i); 11432 } 11433 public TheadContext(ParserRuleContext parent, int invokingState) { 11434 super(parent, invokingState); 11435 } 11436 @Override public int getRuleIndex() { return RULE_thead; } 11437 @Override 11438 public void enterRule(ParseTreeListener listener) { 11439 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterThead(this); 11440 } 11441 @Override 11442 public void exitRule(ParseTreeListener listener) { 11443 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitThead(this); 11444 } 11445 @Override 11446 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11447 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThead(this); 11448 else return visitor.visitChildren(this); 11449 } 11450 } 11451 11452 public final TheadContext thead() throws RecognitionException { 11453 TheadContext _localctx = new TheadContext(_ctx, getState()); 11454 enterRule(_localctx, 100, RULE_thead); 11455 try { 11456 int _alt; 11457 enterOuterAlt(_localctx, 1); 11458 { 11459 setState(1296); 11460 theadTagOpen(); 11461 setState(1336); 11462 _errHandler.sync(this); 11463 _alt = getInterpreter().adaptivePredict(_input,91,_ctx); 11464 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 11465 if ( _alt==1 ) { 11466 { 11467 setState(1334); 11468 _errHandler.sync(this); 11469 switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) { 11470 case 1: 11471 { 11472 setState(1297); 11473 htmlTag(); 11474 } 11475 break; 11476 case 2: 11477 { 11478 setState(1298); 11479 singletonTag(); 11480 } 11481 break; 11482 case 3: 11483 { 11484 setState(1299); 11485 paragraph(); 11486 } 11487 break; 11488 case 4: 11489 { 11490 setState(1300); 11491 li(); 11492 } 11493 break; 11494 case 5: 11495 { 11496 setState(1301); 11497 tr(); 11498 } 11499 break; 11500 case 6: 11501 { 11502 setState(1302); 11503 td(); 11504 } 11505 break; 11506 case 7: 11507 { 11508 setState(1303); 11509 th(); 11510 } 11511 break; 11512 case 8: 11513 { 11514 setState(1304); 11515 body(); 11516 } 11517 break; 11518 case 9: 11519 { 11520 setState(1305); 11521 colgroup(); 11522 } 11523 break; 11524 case 10: 11525 { 11526 setState(1306); 11527 dd(); 11528 } 11529 break; 11530 case 11: 11531 { 11532 setState(1307); 11533 dt(); 11534 } 11535 break; 11536 case 12: 11537 { 11538 setState(1308); 11539 head(); 11540 } 11541 break; 11542 case 13: 11543 { 11544 setState(1309); 11545 html(); 11546 } 11547 break; 11548 case 14: 11549 { 11550 setState(1310); 11551 option(); 11552 } 11553 break; 11554 case 15: 11555 { 11556 setState(1311); 11557 tbody(); 11558 } 11559 break; 11560 case 16: 11561 { 11562 setState(1312); 11563 tfoot(); 11564 } 11565 break; 11566 case 17: 11567 { 11568 setState(1313); 11569 pTagOpen(); 11570 } 11571 break; 11572 case 18: 11573 { 11574 setState(1314); 11575 liTagOpen(); 11576 } 11577 break; 11578 case 19: 11579 { 11580 setState(1315); 11581 trTagOpen(); 11582 } 11583 break; 11584 case 20: 11585 { 11586 setState(1316); 11587 tdTagOpen(); 11588 } 11589 break; 11590 case 21: 11591 { 11592 setState(1317); 11593 thTagOpen(); 11594 } 11595 break; 11596 case 22: 11597 { 11598 setState(1318); 11599 bodyTagOpen(); 11600 } 11601 break; 11602 case 23: 11603 { 11604 setState(1319); 11605 colgroupTagOpen(); 11606 } 11607 break; 11608 case 24: 11609 { 11610 setState(1320); 11611 ddTagOpen(); 11612 } 11613 break; 11614 case 25: 11615 { 11616 setState(1321); 11617 dtTagOpen(); 11618 } 11619 break; 11620 case 26: 11621 { 11622 setState(1322); 11623 headTagOpen(); 11624 } 11625 break; 11626 case 27: 11627 { 11628 setState(1323); 11629 htmlTagOpen(); 11630 } 11631 break; 11632 case 28: 11633 { 11634 setState(1324); 11635 optionTagOpen(); 11636 } 11637 break; 11638 case 29: 11639 { 11640 setState(1325); 11641 tbodyTagOpen(); 11642 } 11643 break; 11644 case 30: 11645 { 11646 setState(1326); 11647 tfootTagOpen(); 11648 } 11649 break; 11650 case 31: 11651 { 11652 { 11653 setState(1327); 11654 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 11655 setState(1328); 11656 match(LEADING_ASTERISK); 11657 } 11658 } 11659 break; 11660 case 32: 11661 { 11662 setState(1329); 11663 htmlComment(); 11664 } 11665 break; 11666 case 33: 11667 { 11668 setState(1330); 11669 match(CDATA); 11670 } 11671 break; 11672 case 34: 11673 { 11674 setState(1331); 11675 match(NEWLINE); 11676 } 11677 break; 11678 case 35: 11679 { 11680 setState(1332); 11681 text(); 11682 } 11683 break; 11684 case 36: 11685 { 11686 setState(1333); 11687 javadocInlineTag(); 11688 } 11689 break; 11690 } 11691 } 11692 } 11693 setState(1338); 11694 _errHandler.sync(this); 11695 _alt = getInterpreter().adaptivePredict(_input,91,_ctx); 11696 } 11697 setState(1339); 11698 theadTagClose(); 11699 } 11700 } 11701 catch (RecognitionException re) { 11702 _localctx.exception = re; 11703 _errHandler.reportError(this, re); 11704 _errHandler.recover(this, re); 11705 } 11706 finally { 11707 exitRule(); 11708 } 11709 return _localctx; 11710 } 11711 11712 public static class SingletonElementContext extends ParserRuleContext { 11713 public SingletonTagContext singletonTag() { 11714 return getRuleContext(SingletonTagContext.class,0); 11715 } 11716 public AreaTagContext areaTag() { 11717 return getRuleContext(AreaTagContext.class,0); 11718 } 11719 public BaseTagContext baseTag() { 11720 return getRuleContext(BaseTagContext.class,0); 11721 } 11722 public BasefontTagContext basefontTag() { 11723 return getRuleContext(BasefontTagContext.class,0); 11724 } 11725 public BrTagContext brTag() { 11726 return getRuleContext(BrTagContext.class,0); 11727 } 11728 public ColTagContext colTag() { 11729 return getRuleContext(ColTagContext.class,0); 11730 } 11731 public FrameTagContext frameTag() { 11732 return getRuleContext(FrameTagContext.class,0); 11733 } 11734 public HrTagContext hrTag() { 11735 return getRuleContext(HrTagContext.class,0); 11736 } 11737 public ImgTagContext imgTag() { 11738 return getRuleContext(ImgTagContext.class,0); 11739 } 11740 public InputTagContext inputTag() { 11741 return getRuleContext(InputTagContext.class,0); 11742 } 11743 public IsindexTagContext isindexTag() { 11744 return getRuleContext(IsindexTagContext.class,0); 11745 } 11746 public LinkTagContext linkTag() { 11747 return getRuleContext(LinkTagContext.class,0); 11748 } 11749 public MetaTagContext metaTag() { 11750 return getRuleContext(MetaTagContext.class,0); 11751 } 11752 public ParamTagContext paramTag() { 11753 return getRuleContext(ParamTagContext.class,0); 11754 } 11755 public WrongSinletonTagContext wrongSinletonTag() { 11756 return getRuleContext(WrongSinletonTagContext.class,0); 11757 } 11758 public SingletonElementContext(ParserRuleContext parent, int invokingState) { 11759 super(parent, invokingState); 11760 } 11761 @Override public int getRuleIndex() { return RULE_singletonElement; } 11762 @Override 11763 public void enterRule(ParseTreeListener listener) { 11764 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonElement(this); 11765 } 11766 @Override 11767 public void exitRule(ParseTreeListener listener) { 11768 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonElement(this); 11769 } 11770 @Override 11771 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11772 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonElement(this); 11773 else return visitor.visitChildren(this); 11774 } 11775 } 11776 11777 public final SingletonElementContext singletonElement() throws RecognitionException { 11778 SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState()); 11779 enterRule(_localctx, 102, RULE_singletonElement); 11780 try { 11781 setState(1356); 11782 _errHandler.sync(this); 11783 switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) { 11784 case 1: 11785 enterOuterAlt(_localctx, 1); 11786 { 11787 setState(1341); 11788 singletonTag(); 11789 } 11790 break; 11791 case 2: 11792 enterOuterAlt(_localctx, 2); 11793 { 11794 setState(1342); 11795 areaTag(); 11796 } 11797 break; 11798 case 3: 11799 enterOuterAlt(_localctx, 3); 11800 { 11801 setState(1343); 11802 baseTag(); 11803 } 11804 break; 11805 case 4: 11806 enterOuterAlt(_localctx, 4); 11807 { 11808 setState(1344); 11809 basefontTag(); 11810 } 11811 break; 11812 case 5: 11813 enterOuterAlt(_localctx, 5); 11814 { 11815 setState(1345); 11816 brTag(); 11817 } 11818 break; 11819 case 6: 11820 enterOuterAlt(_localctx, 6); 11821 { 11822 setState(1346); 11823 colTag(); 11824 } 11825 break; 11826 case 7: 11827 enterOuterAlt(_localctx, 7); 11828 { 11829 setState(1347); 11830 frameTag(); 11831 } 11832 break; 11833 case 8: 11834 enterOuterAlt(_localctx, 8); 11835 { 11836 setState(1348); 11837 hrTag(); 11838 } 11839 break; 11840 case 9: 11841 enterOuterAlt(_localctx, 9); 11842 { 11843 setState(1349); 11844 imgTag(); 11845 } 11846 break; 11847 case 10: 11848 enterOuterAlt(_localctx, 10); 11849 { 11850 setState(1350); 11851 inputTag(); 11852 } 11853 break; 11854 case 11: 11855 enterOuterAlt(_localctx, 11); 11856 { 11857 setState(1351); 11858 isindexTag(); 11859 } 11860 break; 11861 case 12: 11862 enterOuterAlt(_localctx, 12); 11863 { 11864 setState(1352); 11865 linkTag(); 11866 } 11867 break; 11868 case 13: 11869 enterOuterAlt(_localctx, 13); 11870 { 11871 setState(1353); 11872 metaTag(); 11873 } 11874 break; 11875 case 14: 11876 enterOuterAlt(_localctx, 14); 11877 { 11878 setState(1354); 11879 paramTag(); 11880 } 11881 break; 11882 case 15: 11883 enterOuterAlt(_localctx, 15); 11884 { 11885 setState(1355); 11886 wrongSinletonTag(); 11887 } 11888 break; 11889 } 11890 } 11891 catch (RecognitionException re) { 11892 _localctx.exception = re; 11893 _errHandler.reportError(this, re); 11894 _errHandler.recover(this, re); 11895 } 11896 finally { 11897 exitRule(); 11898 } 11899 return _localctx; 11900 } 11901 11902 public static class SingletonTagContext extends ParserRuleContext { 11903 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 11904 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 11905 public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } 11906 public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } 11907 public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } 11908 public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } 11909 public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } 11910 public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } 11911 public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } 11912 public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } 11913 public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } 11914 public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } 11915 public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } 11916 public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } 11917 public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } 11918 public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } 11919 public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } 11920 public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } 11921 public List<AttributeContext> attribute() { 11922 return getRuleContexts(AttributeContext.class); 11923 } 11924 public AttributeContext attribute(int i) { 11925 return getRuleContext(AttributeContext.class,i); 11926 } 11927 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 11928 public TerminalNode NEWLINE(int i) { 11929 return getToken(JavadocParser.NEWLINE, i); 11930 } 11931 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 11932 public TerminalNode LEADING_ASTERISK(int i) { 11933 return getToken(JavadocParser.LEADING_ASTERISK, i); 11934 } 11935 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 11936 public TerminalNode WS(int i) { 11937 return getToken(JavadocParser.WS, i); 11938 } 11939 public SingletonTagContext(ParserRuleContext parent, int invokingState) { 11940 super(parent, invokingState); 11941 } 11942 @Override public int getRuleIndex() { return RULE_singletonTag; } 11943 @Override 11944 public void enterRule(ParseTreeListener listener) { 11945 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTag(this); 11946 } 11947 @Override 11948 public void exitRule(ParseTreeListener listener) { 11949 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTag(this); 11950 } 11951 @Override 11952 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 11953 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTag(this); 11954 else return visitor.visitChildren(this); 11955 } 11956 } 11957 11958 public final SingletonTagContext singletonTag() throws RecognitionException { 11959 SingletonTagContext _localctx = new SingletonTagContext(_ctx, getState()); 11960 enterRule(_localctx, 104, RULE_singletonTag); 11961 int _la; 11962 try { 11963 enterOuterAlt(_localctx, 1); 11964 { 11965 setState(1358); 11966 match(OPEN); 11967 setState(1359); 11968 _la = _input.LA(1); 11969 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)) ) { 11970 _errHandler.recoverInline(this); 11971 } else { 11972 consume(); 11973 } 11974 setState(1366); 11975 _errHandler.sync(this); 11976 _la = _input.LA(1); 11977 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 11978 { 11979 setState(1364); 11980 switch (_input.LA(1)) { 11981 case HTML_TAG_NAME: 11982 { 11983 setState(1360); 11984 attribute(); 11985 } 11986 break; 11987 case NEWLINE: 11988 { 11989 setState(1361); 11990 match(NEWLINE); 11991 } 11992 break; 11993 case LEADING_ASTERISK: 11994 { 11995 setState(1362); 11996 match(LEADING_ASTERISK); 11997 } 11998 break; 11999 case WS: 12000 { 12001 setState(1363); 12002 match(WS); 12003 } 12004 break; 12005 default: 12006 throw new NoViableAltException(this); 12007 } 12008 } 12009 setState(1368); 12010 _errHandler.sync(this); 12011 _la = _input.LA(1); 12012 } 12013 setState(1369); 12014 match(SLASH_CLOSE); 12015 } 12016 } 12017 catch (RecognitionException re) { 12018 _localctx.exception = re; 12019 _errHandler.reportError(this, re); 12020 _errHandler.recover(this, re); 12021 } 12022 finally { 12023 exitRule(); 12024 } 12025 return _localctx; 12026 } 12027 12028 public static class AreaTagContext extends ParserRuleContext { 12029 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12030 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 12031 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12032 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12033 public List<AttributeContext> attribute() { 12034 return getRuleContexts(AttributeContext.class); 12035 } 12036 public AttributeContext attribute(int i) { 12037 return getRuleContext(AttributeContext.class,i); 12038 } 12039 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12040 public TerminalNode NEWLINE(int i) { 12041 return getToken(JavadocParser.NEWLINE, i); 12042 } 12043 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12044 public TerminalNode LEADING_ASTERISK(int i) { 12045 return getToken(JavadocParser.LEADING_ASTERISK, i); 12046 } 12047 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12048 public TerminalNode WS(int i) { 12049 return getToken(JavadocParser.WS, i); 12050 } 12051 public AreaTagContext(ParserRuleContext parent, int invokingState) { 12052 super(parent, invokingState); 12053 } 12054 @Override public int getRuleIndex() { return RULE_areaTag; } 12055 @Override 12056 public void enterRule(ParseTreeListener listener) { 12057 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterAreaTag(this); 12058 } 12059 @Override 12060 public void exitRule(ParseTreeListener listener) { 12061 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitAreaTag(this); 12062 } 12063 @Override 12064 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12065 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAreaTag(this); 12066 else return visitor.visitChildren(this); 12067 } 12068 } 12069 12070 public final AreaTagContext areaTag() throws RecognitionException { 12071 AreaTagContext _localctx = new AreaTagContext(_ctx, getState()); 12072 enterRule(_localctx, 106, RULE_areaTag); 12073 int _la; 12074 try { 12075 enterOuterAlt(_localctx, 1); 12076 { 12077 setState(1371); 12078 match(OPEN); 12079 setState(1372); 12080 match(AREA_HTML_TAG_NAME); 12081 setState(1379); 12082 _errHandler.sync(this); 12083 _la = _input.LA(1); 12084 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12085 { 12086 setState(1377); 12087 switch (_input.LA(1)) { 12088 case HTML_TAG_NAME: 12089 { 12090 setState(1373); 12091 attribute(); 12092 } 12093 break; 12094 case NEWLINE: 12095 { 12096 setState(1374); 12097 match(NEWLINE); 12098 } 12099 break; 12100 case LEADING_ASTERISK: 12101 { 12102 setState(1375); 12103 match(LEADING_ASTERISK); 12104 } 12105 break; 12106 case WS: 12107 { 12108 setState(1376); 12109 match(WS); 12110 } 12111 break; 12112 default: 12113 throw new NoViableAltException(this); 12114 } 12115 } 12116 setState(1381); 12117 _errHandler.sync(this); 12118 _la = _input.LA(1); 12119 } 12120 setState(1382); 12121 _la = _input.LA(1); 12122 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12123 _errHandler.recoverInline(this); 12124 } else { 12125 consume(); 12126 } 12127 } 12128 } 12129 catch (RecognitionException re) { 12130 _localctx.exception = re; 12131 _errHandler.reportError(this, re); 12132 _errHandler.recover(this, re); 12133 } 12134 finally { 12135 exitRule(); 12136 } 12137 return _localctx; 12138 } 12139 12140 public static class BaseTagContext extends ParserRuleContext { 12141 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12142 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 12143 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12144 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12145 public List<AttributeContext> attribute() { 12146 return getRuleContexts(AttributeContext.class); 12147 } 12148 public AttributeContext attribute(int i) { 12149 return getRuleContext(AttributeContext.class,i); 12150 } 12151 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12152 public TerminalNode NEWLINE(int i) { 12153 return getToken(JavadocParser.NEWLINE, i); 12154 } 12155 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12156 public TerminalNode LEADING_ASTERISK(int i) { 12157 return getToken(JavadocParser.LEADING_ASTERISK, i); 12158 } 12159 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12160 public TerminalNode WS(int i) { 12161 return getToken(JavadocParser.WS, i); 12162 } 12163 public BaseTagContext(ParserRuleContext parent, int invokingState) { 12164 super(parent, invokingState); 12165 } 12166 @Override public int getRuleIndex() { return RULE_baseTag; } 12167 @Override 12168 public void enterRule(ParseTreeListener listener) { 12169 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBaseTag(this); 12170 } 12171 @Override 12172 public void exitRule(ParseTreeListener listener) { 12173 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBaseTag(this); 12174 } 12175 @Override 12176 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12177 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBaseTag(this); 12178 else return visitor.visitChildren(this); 12179 } 12180 } 12181 12182 public final BaseTagContext baseTag() throws RecognitionException { 12183 BaseTagContext _localctx = new BaseTagContext(_ctx, getState()); 12184 enterRule(_localctx, 108, RULE_baseTag); 12185 int _la; 12186 try { 12187 enterOuterAlt(_localctx, 1); 12188 { 12189 setState(1384); 12190 match(OPEN); 12191 setState(1385); 12192 match(BASE_HTML_TAG_NAME); 12193 setState(1392); 12194 _errHandler.sync(this); 12195 _la = _input.LA(1); 12196 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12197 { 12198 setState(1390); 12199 switch (_input.LA(1)) { 12200 case HTML_TAG_NAME: 12201 { 12202 setState(1386); 12203 attribute(); 12204 } 12205 break; 12206 case NEWLINE: 12207 { 12208 setState(1387); 12209 match(NEWLINE); 12210 } 12211 break; 12212 case LEADING_ASTERISK: 12213 { 12214 setState(1388); 12215 match(LEADING_ASTERISK); 12216 } 12217 break; 12218 case WS: 12219 { 12220 setState(1389); 12221 match(WS); 12222 } 12223 break; 12224 default: 12225 throw new NoViableAltException(this); 12226 } 12227 } 12228 setState(1394); 12229 _errHandler.sync(this); 12230 _la = _input.LA(1); 12231 } 12232 setState(1395); 12233 _la = _input.LA(1); 12234 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12235 _errHandler.recoverInline(this); 12236 } else { 12237 consume(); 12238 } 12239 } 12240 } 12241 catch (RecognitionException re) { 12242 _localctx.exception = re; 12243 _errHandler.reportError(this, re); 12244 _errHandler.recover(this, re); 12245 } 12246 finally { 12247 exitRule(); 12248 } 12249 return _localctx; 12250 } 12251 12252 public static class BasefontTagContext extends ParserRuleContext { 12253 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12254 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 12255 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12256 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12257 public List<AttributeContext> attribute() { 12258 return getRuleContexts(AttributeContext.class); 12259 } 12260 public AttributeContext attribute(int i) { 12261 return getRuleContext(AttributeContext.class,i); 12262 } 12263 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12264 public TerminalNode NEWLINE(int i) { 12265 return getToken(JavadocParser.NEWLINE, i); 12266 } 12267 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12268 public TerminalNode LEADING_ASTERISK(int i) { 12269 return getToken(JavadocParser.LEADING_ASTERISK, i); 12270 } 12271 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12272 public TerminalNode WS(int i) { 12273 return getToken(JavadocParser.WS, i); 12274 } 12275 public BasefontTagContext(ParserRuleContext parent, int invokingState) { 12276 super(parent, invokingState); 12277 } 12278 @Override public int getRuleIndex() { return RULE_basefontTag; } 12279 @Override 12280 public void enterRule(ParseTreeListener listener) { 12281 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBasefontTag(this); 12282 } 12283 @Override 12284 public void exitRule(ParseTreeListener listener) { 12285 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBasefontTag(this); 12286 } 12287 @Override 12288 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12289 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBasefontTag(this); 12290 else return visitor.visitChildren(this); 12291 } 12292 } 12293 12294 public final BasefontTagContext basefontTag() throws RecognitionException { 12295 BasefontTagContext _localctx = new BasefontTagContext(_ctx, getState()); 12296 enterRule(_localctx, 110, RULE_basefontTag); 12297 int _la; 12298 try { 12299 enterOuterAlt(_localctx, 1); 12300 { 12301 setState(1397); 12302 match(OPEN); 12303 setState(1398); 12304 match(BASEFONT_HTML_TAG_NAME); 12305 setState(1405); 12306 _errHandler.sync(this); 12307 _la = _input.LA(1); 12308 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12309 { 12310 setState(1403); 12311 switch (_input.LA(1)) { 12312 case HTML_TAG_NAME: 12313 { 12314 setState(1399); 12315 attribute(); 12316 } 12317 break; 12318 case NEWLINE: 12319 { 12320 setState(1400); 12321 match(NEWLINE); 12322 } 12323 break; 12324 case LEADING_ASTERISK: 12325 { 12326 setState(1401); 12327 match(LEADING_ASTERISK); 12328 } 12329 break; 12330 case WS: 12331 { 12332 setState(1402); 12333 match(WS); 12334 } 12335 break; 12336 default: 12337 throw new NoViableAltException(this); 12338 } 12339 } 12340 setState(1407); 12341 _errHandler.sync(this); 12342 _la = _input.LA(1); 12343 } 12344 setState(1408); 12345 _la = _input.LA(1); 12346 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12347 _errHandler.recoverInline(this); 12348 } else { 12349 consume(); 12350 } 12351 } 12352 } 12353 catch (RecognitionException re) { 12354 _localctx.exception = re; 12355 _errHandler.reportError(this, re); 12356 _errHandler.recover(this, re); 12357 } 12358 finally { 12359 exitRule(); 12360 } 12361 return _localctx; 12362 } 12363 12364 public static class BrTagContext extends ParserRuleContext { 12365 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12366 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 12367 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12368 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12369 public List<AttributeContext> attribute() { 12370 return getRuleContexts(AttributeContext.class); 12371 } 12372 public AttributeContext attribute(int i) { 12373 return getRuleContext(AttributeContext.class,i); 12374 } 12375 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12376 public TerminalNode NEWLINE(int i) { 12377 return getToken(JavadocParser.NEWLINE, i); 12378 } 12379 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12380 public TerminalNode LEADING_ASTERISK(int i) { 12381 return getToken(JavadocParser.LEADING_ASTERISK, i); 12382 } 12383 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12384 public TerminalNode WS(int i) { 12385 return getToken(JavadocParser.WS, i); 12386 } 12387 public BrTagContext(ParserRuleContext parent, int invokingState) { 12388 super(parent, invokingState); 12389 } 12390 @Override public int getRuleIndex() { return RULE_brTag; } 12391 @Override 12392 public void enterRule(ParseTreeListener listener) { 12393 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterBrTag(this); 12394 } 12395 @Override 12396 public void exitRule(ParseTreeListener listener) { 12397 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitBrTag(this); 12398 } 12399 @Override 12400 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12401 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBrTag(this); 12402 else return visitor.visitChildren(this); 12403 } 12404 } 12405 12406 public final BrTagContext brTag() throws RecognitionException { 12407 BrTagContext _localctx = new BrTagContext(_ctx, getState()); 12408 enterRule(_localctx, 112, RULE_brTag); 12409 int _la; 12410 try { 12411 enterOuterAlt(_localctx, 1); 12412 { 12413 setState(1410); 12414 match(OPEN); 12415 setState(1411); 12416 match(BR_HTML_TAG_NAME); 12417 setState(1418); 12418 _errHandler.sync(this); 12419 _la = _input.LA(1); 12420 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12421 { 12422 setState(1416); 12423 switch (_input.LA(1)) { 12424 case HTML_TAG_NAME: 12425 { 12426 setState(1412); 12427 attribute(); 12428 } 12429 break; 12430 case NEWLINE: 12431 { 12432 setState(1413); 12433 match(NEWLINE); 12434 } 12435 break; 12436 case LEADING_ASTERISK: 12437 { 12438 setState(1414); 12439 match(LEADING_ASTERISK); 12440 } 12441 break; 12442 case WS: 12443 { 12444 setState(1415); 12445 match(WS); 12446 } 12447 break; 12448 default: 12449 throw new NoViableAltException(this); 12450 } 12451 } 12452 setState(1420); 12453 _errHandler.sync(this); 12454 _la = _input.LA(1); 12455 } 12456 setState(1421); 12457 _la = _input.LA(1); 12458 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12459 _errHandler.recoverInline(this); 12460 } else { 12461 consume(); 12462 } 12463 } 12464 } 12465 catch (RecognitionException re) { 12466 _localctx.exception = re; 12467 _errHandler.reportError(this, re); 12468 _errHandler.recover(this, re); 12469 } 12470 finally { 12471 exitRule(); 12472 } 12473 return _localctx; 12474 } 12475 12476 public static class ColTagContext extends ParserRuleContext { 12477 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12478 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 12479 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12480 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12481 public List<AttributeContext> attribute() { 12482 return getRuleContexts(AttributeContext.class); 12483 } 12484 public AttributeContext attribute(int i) { 12485 return getRuleContext(AttributeContext.class,i); 12486 } 12487 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12488 public TerminalNode NEWLINE(int i) { 12489 return getToken(JavadocParser.NEWLINE, i); 12490 } 12491 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12492 public TerminalNode LEADING_ASTERISK(int i) { 12493 return getToken(JavadocParser.LEADING_ASTERISK, i); 12494 } 12495 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12496 public TerminalNode WS(int i) { 12497 return getToken(JavadocParser.WS, i); 12498 } 12499 public ColTagContext(ParserRuleContext parent, int invokingState) { 12500 super(parent, invokingState); 12501 } 12502 @Override public int getRuleIndex() { return RULE_colTag; } 12503 @Override 12504 public void enterRule(ParseTreeListener listener) { 12505 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterColTag(this); 12506 } 12507 @Override 12508 public void exitRule(ParseTreeListener listener) { 12509 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitColTag(this); 12510 } 12511 @Override 12512 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12513 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColTag(this); 12514 else return visitor.visitChildren(this); 12515 } 12516 } 12517 12518 public final ColTagContext colTag() throws RecognitionException { 12519 ColTagContext _localctx = new ColTagContext(_ctx, getState()); 12520 enterRule(_localctx, 114, RULE_colTag); 12521 int _la; 12522 try { 12523 enterOuterAlt(_localctx, 1); 12524 { 12525 setState(1423); 12526 match(OPEN); 12527 setState(1424); 12528 match(COL_HTML_TAG_NAME); 12529 setState(1431); 12530 _errHandler.sync(this); 12531 _la = _input.LA(1); 12532 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12533 { 12534 setState(1429); 12535 switch (_input.LA(1)) { 12536 case HTML_TAG_NAME: 12537 { 12538 setState(1425); 12539 attribute(); 12540 } 12541 break; 12542 case NEWLINE: 12543 { 12544 setState(1426); 12545 match(NEWLINE); 12546 } 12547 break; 12548 case LEADING_ASTERISK: 12549 { 12550 setState(1427); 12551 match(LEADING_ASTERISK); 12552 } 12553 break; 12554 case WS: 12555 { 12556 setState(1428); 12557 match(WS); 12558 } 12559 break; 12560 default: 12561 throw new NoViableAltException(this); 12562 } 12563 } 12564 setState(1433); 12565 _errHandler.sync(this); 12566 _la = _input.LA(1); 12567 } 12568 setState(1434); 12569 _la = _input.LA(1); 12570 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12571 _errHandler.recoverInline(this); 12572 } else { 12573 consume(); 12574 } 12575 } 12576 } 12577 catch (RecognitionException re) { 12578 _localctx.exception = re; 12579 _errHandler.reportError(this, re); 12580 _errHandler.recover(this, re); 12581 } 12582 finally { 12583 exitRule(); 12584 } 12585 return _localctx; 12586 } 12587 12588 public static class FrameTagContext extends ParserRuleContext { 12589 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12590 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 12591 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12592 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12593 public List<AttributeContext> attribute() { 12594 return getRuleContexts(AttributeContext.class); 12595 } 12596 public AttributeContext attribute(int i) { 12597 return getRuleContext(AttributeContext.class,i); 12598 } 12599 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12600 public TerminalNode NEWLINE(int i) { 12601 return getToken(JavadocParser.NEWLINE, i); 12602 } 12603 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12604 public TerminalNode LEADING_ASTERISK(int i) { 12605 return getToken(JavadocParser.LEADING_ASTERISK, i); 12606 } 12607 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12608 public TerminalNode WS(int i) { 12609 return getToken(JavadocParser.WS, i); 12610 } 12611 public FrameTagContext(ParserRuleContext parent, int invokingState) { 12612 super(parent, invokingState); 12613 } 12614 @Override public int getRuleIndex() { return RULE_frameTag; } 12615 @Override 12616 public void enterRule(ParseTreeListener listener) { 12617 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterFrameTag(this); 12618 } 12619 @Override 12620 public void exitRule(ParseTreeListener listener) { 12621 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitFrameTag(this); 12622 } 12623 @Override 12624 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12625 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitFrameTag(this); 12626 else return visitor.visitChildren(this); 12627 } 12628 } 12629 12630 public final FrameTagContext frameTag() throws RecognitionException { 12631 FrameTagContext _localctx = new FrameTagContext(_ctx, getState()); 12632 enterRule(_localctx, 116, RULE_frameTag); 12633 int _la; 12634 try { 12635 enterOuterAlt(_localctx, 1); 12636 { 12637 setState(1436); 12638 match(OPEN); 12639 setState(1437); 12640 match(FRAME_HTML_TAG_NAME); 12641 setState(1444); 12642 _errHandler.sync(this); 12643 _la = _input.LA(1); 12644 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12645 { 12646 setState(1442); 12647 switch (_input.LA(1)) { 12648 case HTML_TAG_NAME: 12649 { 12650 setState(1438); 12651 attribute(); 12652 } 12653 break; 12654 case NEWLINE: 12655 { 12656 setState(1439); 12657 match(NEWLINE); 12658 } 12659 break; 12660 case LEADING_ASTERISK: 12661 { 12662 setState(1440); 12663 match(LEADING_ASTERISK); 12664 } 12665 break; 12666 case WS: 12667 { 12668 setState(1441); 12669 match(WS); 12670 } 12671 break; 12672 default: 12673 throw new NoViableAltException(this); 12674 } 12675 } 12676 setState(1446); 12677 _errHandler.sync(this); 12678 _la = _input.LA(1); 12679 } 12680 setState(1447); 12681 _la = _input.LA(1); 12682 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12683 _errHandler.recoverInline(this); 12684 } else { 12685 consume(); 12686 } 12687 } 12688 } 12689 catch (RecognitionException re) { 12690 _localctx.exception = re; 12691 _errHandler.reportError(this, re); 12692 _errHandler.recover(this, re); 12693 } 12694 finally { 12695 exitRule(); 12696 } 12697 return _localctx; 12698 } 12699 12700 public static class HrTagContext extends ParserRuleContext { 12701 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12702 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 12703 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12704 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12705 public List<AttributeContext> attribute() { 12706 return getRuleContexts(AttributeContext.class); 12707 } 12708 public AttributeContext attribute(int i) { 12709 return getRuleContext(AttributeContext.class,i); 12710 } 12711 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12712 public TerminalNode NEWLINE(int i) { 12713 return getToken(JavadocParser.NEWLINE, i); 12714 } 12715 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12716 public TerminalNode LEADING_ASTERISK(int i) { 12717 return getToken(JavadocParser.LEADING_ASTERISK, i); 12718 } 12719 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12720 public TerminalNode WS(int i) { 12721 return getToken(JavadocParser.WS, i); 12722 } 12723 public HrTagContext(ParserRuleContext parent, int invokingState) { 12724 super(parent, invokingState); 12725 } 12726 @Override public int getRuleIndex() { return RULE_hrTag; } 12727 @Override 12728 public void enterRule(ParseTreeListener listener) { 12729 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHrTag(this); 12730 } 12731 @Override 12732 public void exitRule(ParseTreeListener listener) { 12733 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHrTag(this); 12734 } 12735 @Override 12736 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12737 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHrTag(this); 12738 else return visitor.visitChildren(this); 12739 } 12740 } 12741 12742 public final HrTagContext hrTag() throws RecognitionException { 12743 HrTagContext _localctx = new HrTagContext(_ctx, getState()); 12744 enterRule(_localctx, 118, RULE_hrTag); 12745 int _la; 12746 try { 12747 enterOuterAlt(_localctx, 1); 12748 { 12749 setState(1449); 12750 match(OPEN); 12751 setState(1450); 12752 match(HR_HTML_TAG_NAME); 12753 setState(1457); 12754 _errHandler.sync(this); 12755 _la = _input.LA(1); 12756 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12757 { 12758 setState(1455); 12759 switch (_input.LA(1)) { 12760 case HTML_TAG_NAME: 12761 { 12762 setState(1451); 12763 attribute(); 12764 } 12765 break; 12766 case NEWLINE: 12767 { 12768 setState(1452); 12769 match(NEWLINE); 12770 } 12771 break; 12772 case LEADING_ASTERISK: 12773 { 12774 setState(1453); 12775 match(LEADING_ASTERISK); 12776 } 12777 break; 12778 case WS: 12779 { 12780 setState(1454); 12781 match(WS); 12782 } 12783 break; 12784 default: 12785 throw new NoViableAltException(this); 12786 } 12787 } 12788 setState(1459); 12789 _errHandler.sync(this); 12790 _la = _input.LA(1); 12791 } 12792 setState(1460); 12793 _la = _input.LA(1); 12794 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12795 _errHandler.recoverInline(this); 12796 } else { 12797 consume(); 12798 } 12799 } 12800 } 12801 catch (RecognitionException re) { 12802 _localctx.exception = re; 12803 _errHandler.reportError(this, re); 12804 _errHandler.recover(this, re); 12805 } 12806 finally { 12807 exitRule(); 12808 } 12809 return _localctx; 12810 } 12811 12812 public static class ImgTagContext extends ParserRuleContext { 12813 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12814 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 12815 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12816 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12817 public List<AttributeContext> attribute() { 12818 return getRuleContexts(AttributeContext.class); 12819 } 12820 public AttributeContext attribute(int i) { 12821 return getRuleContext(AttributeContext.class,i); 12822 } 12823 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12824 public TerminalNode NEWLINE(int i) { 12825 return getToken(JavadocParser.NEWLINE, i); 12826 } 12827 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12828 public TerminalNode LEADING_ASTERISK(int i) { 12829 return getToken(JavadocParser.LEADING_ASTERISK, i); 12830 } 12831 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12832 public TerminalNode WS(int i) { 12833 return getToken(JavadocParser.WS, i); 12834 } 12835 public ImgTagContext(ParserRuleContext parent, int invokingState) { 12836 super(parent, invokingState); 12837 } 12838 @Override public int getRuleIndex() { return RULE_imgTag; } 12839 @Override 12840 public void enterRule(ParseTreeListener listener) { 12841 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterImgTag(this); 12842 } 12843 @Override 12844 public void exitRule(ParseTreeListener listener) { 12845 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitImgTag(this); 12846 } 12847 @Override 12848 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12849 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitImgTag(this); 12850 else return visitor.visitChildren(this); 12851 } 12852 } 12853 12854 public final ImgTagContext imgTag() throws RecognitionException { 12855 ImgTagContext _localctx = new ImgTagContext(_ctx, getState()); 12856 enterRule(_localctx, 120, RULE_imgTag); 12857 int _la; 12858 try { 12859 enterOuterAlt(_localctx, 1); 12860 { 12861 setState(1462); 12862 match(OPEN); 12863 setState(1463); 12864 match(IMG_HTML_TAG_NAME); 12865 setState(1470); 12866 _errHandler.sync(this); 12867 _la = _input.LA(1); 12868 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12869 { 12870 setState(1468); 12871 switch (_input.LA(1)) { 12872 case HTML_TAG_NAME: 12873 { 12874 setState(1464); 12875 attribute(); 12876 } 12877 break; 12878 case NEWLINE: 12879 { 12880 setState(1465); 12881 match(NEWLINE); 12882 } 12883 break; 12884 case LEADING_ASTERISK: 12885 { 12886 setState(1466); 12887 match(LEADING_ASTERISK); 12888 } 12889 break; 12890 case WS: 12891 { 12892 setState(1467); 12893 match(WS); 12894 } 12895 break; 12896 default: 12897 throw new NoViableAltException(this); 12898 } 12899 } 12900 setState(1472); 12901 _errHandler.sync(this); 12902 _la = _input.LA(1); 12903 } 12904 setState(1473); 12905 _la = _input.LA(1); 12906 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 12907 _errHandler.recoverInline(this); 12908 } else { 12909 consume(); 12910 } 12911 } 12912 } 12913 catch (RecognitionException re) { 12914 _localctx.exception = re; 12915 _errHandler.reportError(this, re); 12916 _errHandler.recover(this, re); 12917 } 12918 finally { 12919 exitRule(); 12920 } 12921 return _localctx; 12922 } 12923 12924 public static class InputTagContext extends ParserRuleContext { 12925 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 12926 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 12927 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 12928 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 12929 public List<AttributeContext> attribute() { 12930 return getRuleContexts(AttributeContext.class); 12931 } 12932 public AttributeContext attribute(int i) { 12933 return getRuleContext(AttributeContext.class,i); 12934 } 12935 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 12936 public TerminalNode NEWLINE(int i) { 12937 return getToken(JavadocParser.NEWLINE, i); 12938 } 12939 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 12940 public TerminalNode LEADING_ASTERISK(int i) { 12941 return getToken(JavadocParser.LEADING_ASTERISK, i); 12942 } 12943 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 12944 public TerminalNode WS(int i) { 12945 return getToken(JavadocParser.WS, i); 12946 } 12947 public InputTagContext(ParserRuleContext parent, int invokingState) { 12948 super(parent, invokingState); 12949 } 12950 @Override public int getRuleIndex() { return RULE_inputTag; } 12951 @Override 12952 public void enterRule(ParseTreeListener listener) { 12953 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterInputTag(this); 12954 } 12955 @Override 12956 public void exitRule(ParseTreeListener listener) { 12957 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitInputTag(this); 12958 } 12959 @Override 12960 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 12961 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInputTag(this); 12962 else return visitor.visitChildren(this); 12963 } 12964 } 12965 12966 public final InputTagContext inputTag() throws RecognitionException { 12967 InputTagContext _localctx = new InputTagContext(_ctx, getState()); 12968 enterRule(_localctx, 122, RULE_inputTag); 12969 int _la; 12970 try { 12971 enterOuterAlt(_localctx, 1); 12972 { 12973 setState(1475); 12974 match(OPEN); 12975 setState(1476); 12976 match(INPUT_HTML_TAG_NAME); 12977 setState(1483); 12978 _errHandler.sync(this); 12979 _la = _input.LA(1); 12980 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 12981 { 12982 setState(1481); 12983 switch (_input.LA(1)) { 12984 case HTML_TAG_NAME: 12985 { 12986 setState(1477); 12987 attribute(); 12988 } 12989 break; 12990 case NEWLINE: 12991 { 12992 setState(1478); 12993 match(NEWLINE); 12994 } 12995 break; 12996 case LEADING_ASTERISK: 12997 { 12998 setState(1479); 12999 match(LEADING_ASTERISK); 13000 } 13001 break; 13002 case WS: 13003 { 13004 setState(1480); 13005 match(WS); 13006 } 13007 break; 13008 default: 13009 throw new NoViableAltException(this); 13010 } 13011 } 13012 setState(1485); 13013 _errHandler.sync(this); 13014 _la = _input.LA(1); 13015 } 13016 setState(1486); 13017 _la = _input.LA(1); 13018 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13019 _errHandler.recoverInline(this); 13020 } else { 13021 consume(); 13022 } 13023 } 13024 } 13025 catch (RecognitionException re) { 13026 _localctx.exception = re; 13027 _errHandler.reportError(this, re); 13028 _errHandler.recover(this, re); 13029 } 13030 finally { 13031 exitRule(); 13032 } 13033 return _localctx; 13034 } 13035 13036 public static class IsindexTagContext extends ParserRuleContext { 13037 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13038 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 13039 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13040 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13041 public List<AttributeContext> attribute() { 13042 return getRuleContexts(AttributeContext.class); 13043 } 13044 public AttributeContext attribute(int i) { 13045 return getRuleContext(AttributeContext.class,i); 13046 } 13047 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13048 public TerminalNode NEWLINE(int i) { 13049 return getToken(JavadocParser.NEWLINE, i); 13050 } 13051 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13052 public TerminalNode LEADING_ASTERISK(int i) { 13053 return getToken(JavadocParser.LEADING_ASTERISK, i); 13054 } 13055 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13056 public TerminalNode WS(int i) { 13057 return getToken(JavadocParser.WS, i); 13058 } 13059 public IsindexTagContext(ParserRuleContext parent, int invokingState) { 13060 super(parent, invokingState); 13061 } 13062 @Override public int getRuleIndex() { return RULE_isindexTag; } 13063 @Override 13064 public void enterRule(ParseTreeListener listener) { 13065 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterIsindexTag(this); 13066 } 13067 @Override 13068 public void exitRule(ParseTreeListener listener) { 13069 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitIsindexTag(this); 13070 } 13071 @Override 13072 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13073 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitIsindexTag(this); 13074 else return visitor.visitChildren(this); 13075 } 13076 } 13077 13078 public final IsindexTagContext isindexTag() throws RecognitionException { 13079 IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState()); 13080 enterRule(_localctx, 124, RULE_isindexTag); 13081 int _la; 13082 try { 13083 enterOuterAlt(_localctx, 1); 13084 { 13085 setState(1488); 13086 match(OPEN); 13087 setState(1489); 13088 match(ISINDEX_HTML_TAG_NAME); 13089 setState(1496); 13090 _errHandler.sync(this); 13091 _la = _input.LA(1); 13092 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13093 { 13094 setState(1494); 13095 switch (_input.LA(1)) { 13096 case HTML_TAG_NAME: 13097 { 13098 setState(1490); 13099 attribute(); 13100 } 13101 break; 13102 case NEWLINE: 13103 { 13104 setState(1491); 13105 match(NEWLINE); 13106 } 13107 break; 13108 case LEADING_ASTERISK: 13109 { 13110 setState(1492); 13111 match(LEADING_ASTERISK); 13112 } 13113 break; 13114 case WS: 13115 { 13116 setState(1493); 13117 match(WS); 13118 } 13119 break; 13120 default: 13121 throw new NoViableAltException(this); 13122 } 13123 } 13124 setState(1498); 13125 _errHandler.sync(this); 13126 _la = _input.LA(1); 13127 } 13128 setState(1499); 13129 _la = _input.LA(1); 13130 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13131 _errHandler.recoverInline(this); 13132 } else { 13133 consume(); 13134 } 13135 } 13136 } 13137 catch (RecognitionException re) { 13138 _localctx.exception = re; 13139 _errHandler.reportError(this, re); 13140 _errHandler.recover(this, re); 13141 } 13142 finally { 13143 exitRule(); 13144 } 13145 return _localctx; 13146 } 13147 13148 public static class LinkTagContext extends ParserRuleContext { 13149 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13150 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 13151 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13152 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13153 public List<AttributeContext> attribute() { 13154 return getRuleContexts(AttributeContext.class); 13155 } 13156 public AttributeContext attribute(int i) { 13157 return getRuleContext(AttributeContext.class,i); 13158 } 13159 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13160 public TerminalNode NEWLINE(int i) { 13161 return getToken(JavadocParser.NEWLINE, i); 13162 } 13163 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13164 public TerminalNode LEADING_ASTERISK(int i) { 13165 return getToken(JavadocParser.LEADING_ASTERISK, i); 13166 } 13167 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13168 public TerminalNode WS(int i) { 13169 return getToken(JavadocParser.WS, i); 13170 } 13171 public LinkTagContext(ParserRuleContext parent, int invokingState) { 13172 super(parent, invokingState); 13173 } 13174 @Override public int getRuleIndex() { return RULE_linkTag; } 13175 @Override 13176 public void enterRule(ParseTreeListener listener) { 13177 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterLinkTag(this); 13178 } 13179 @Override 13180 public void exitRule(ParseTreeListener listener) { 13181 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitLinkTag(this); 13182 } 13183 @Override 13184 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13185 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLinkTag(this); 13186 else return visitor.visitChildren(this); 13187 } 13188 } 13189 13190 public final LinkTagContext linkTag() throws RecognitionException { 13191 LinkTagContext _localctx = new LinkTagContext(_ctx, getState()); 13192 enterRule(_localctx, 126, RULE_linkTag); 13193 int _la; 13194 try { 13195 enterOuterAlt(_localctx, 1); 13196 { 13197 setState(1501); 13198 match(OPEN); 13199 setState(1502); 13200 match(LINK_HTML_TAG_NAME); 13201 setState(1509); 13202 _errHandler.sync(this); 13203 _la = _input.LA(1); 13204 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13205 { 13206 setState(1507); 13207 switch (_input.LA(1)) { 13208 case HTML_TAG_NAME: 13209 { 13210 setState(1503); 13211 attribute(); 13212 } 13213 break; 13214 case NEWLINE: 13215 { 13216 setState(1504); 13217 match(NEWLINE); 13218 } 13219 break; 13220 case LEADING_ASTERISK: 13221 { 13222 setState(1505); 13223 match(LEADING_ASTERISK); 13224 } 13225 break; 13226 case WS: 13227 { 13228 setState(1506); 13229 match(WS); 13230 } 13231 break; 13232 default: 13233 throw new NoViableAltException(this); 13234 } 13235 } 13236 setState(1511); 13237 _errHandler.sync(this); 13238 _la = _input.LA(1); 13239 } 13240 setState(1512); 13241 _la = _input.LA(1); 13242 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13243 _errHandler.recoverInline(this); 13244 } else { 13245 consume(); 13246 } 13247 } 13248 } 13249 catch (RecognitionException re) { 13250 _localctx.exception = re; 13251 _errHandler.reportError(this, re); 13252 _errHandler.recover(this, re); 13253 } 13254 finally { 13255 exitRule(); 13256 } 13257 return _localctx; 13258 } 13259 13260 public static class MetaTagContext extends ParserRuleContext { 13261 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13262 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 13263 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13264 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13265 public List<AttributeContext> attribute() { 13266 return getRuleContexts(AttributeContext.class); 13267 } 13268 public AttributeContext attribute(int i) { 13269 return getRuleContext(AttributeContext.class,i); 13270 } 13271 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13272 public TerminalNode NEWLINE(int i) { 13273 return getToken(JavadocParser.NEWLINE, i); 13274 } 13275 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13276 public TerminalNode LEADING_ASTERISK(int i) { 13277 return getToken(JavadocParser.LEADING_ASTERISK, i); 13278 } 13279 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13280 public TerminalNode WS(int i) { 13281 return getToken(JavadocParser.WS, i); 13282 } 13283 public MetaTagContext(ParserRuleContext parent, int invokingState) { 13284 super(parent, invokingState); 13285 } 13286 @Override public int getRuleIndex() { return RULE_metaTag; } 13287 @Override 13288 public void enterRule(ParseTreeListener listener) { 13289 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterMetaTag(this); 13290 } 13291 @Override 13292 public void exitRule(ParseTreeListener listener) { 13293 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitMetaTag(this); 13294 } 13295 @Override 13296 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13297 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitMetaTag(this); 13298 else return visitor.visitChildren(this); 13299 } 13300 } 13301 13302 public final MetaTagContext metaTag() throws RecognitionException { 13303 MetaTagContext _localctx = new MetaTagContext(_ctx, getState()); 13304 enterRule(_localctx, 128, RULE_metaTag); 13305 int _la; 13306 try { 13307 enterOuterAlt(_localctx, 1); 13308 { 13309 setState(1514); 13310 match(OPEN); 13311 setState(1515); 13312 match(META_HTML_TAG_NAME); 13313 setState(1522); 13314 _errHandler.sync(this); 13315 _la = _input.LA(1); 13316 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13317 { 13318 setState(1520); 13319 switch (_input.LA(1)) { 13320 case HTML_TAG_NAME: 13321 { 13322 setState(1516); 13323 attribute(); 13324 } 13325 break; 13326 case NEWLINE: 13327 { 13328 setState(1517); 13329 match(NEWLINE); 13330 } 13331 break; 13332 case LEADING_ASTERISK: 13333 { 13334 setState(1518); 13335 match(LEADING_ASTERISK); 13336 } 13337 break; 13338 case WS: 13339 { 13340 setState(1519); 13341 match(WS); 13342 } 13343 break; 13344 default: 13345 throw new NoViableAltException(this); 13346 } 13347 } 13348 setState(1524); 13349 _errHandler.sync(this); 13350 _la = _input.LA(1); 13351 } 13352 setState(1525); 13353 _la = _input.LA(1); 13354 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13355 _errHandler.recoverInline(this); 13356 } else { 13357 consume(); 13358 } 13359 } 13360 } 13361 catch (RecognitionException re) { 13362 _localctx.exception = re; 13363 _errHandler.reportError(this, re); 13364 _errHandler.recover(this, re); 13365 } 13366 finally { 13367 exitRule(); 13368 } 13369 return _localctx; 13370 } 13371 13372 public static class ParamTagContext extends ParserRuleContext { 13373 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13374 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 13375 public TerminalNode SLASH_CLOSE() { return getToken(JavadocParser.SLASH_CLOSE, 0); } 13376 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13377 public List<AttributeContext> attribute() { 13378 return getRuleContexts(AttributeContext.class); 13379 } 13380 public AttributeContext attribute(int i) { 13381 return getRuleContext(AttributeContext.class,i); 13382 } 13383 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13384 public TerminalNode NEWLINE(int i) { 13385 return getToken(JavadocParser.NEWLINE, i); 13386 } 13387 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13388 public TerminalNode LEADING_ASTERISK(int i) { 13389 return getToken(JavadocParser.LEADING_ASTERISK, i); 13390 } 13391 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13392 public TerminalNode WS(int i) { 13393 return getToken(JavadocParser.WS, i); 13394 } 13395 public ParamTagContext(ParserRuleContext parent, int invokingState) { 13396 super(parent, invokingState); 13397 } 13398 @Override public int getRuleIndex() { return RULE_paramTag; } 13399 @Override 13400 public void enterRule(ParseTreeListener listener) { 13401 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParamTag(this); 13402 } 13403 @Override 13404 public void exitRule(ParseTreeListener listener) { 13405 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParamTag(this); 13406 } 13407 @Override 13408 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13409 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParamTag(this); 13410 else return visitor.visitChildren(this); 13411 } 13412 } 13413 13414 public final ParamTagContext paramTag() throws RecognitionException { 13415 ParamTagContext _localctx = new ParamTagContext(_ctx, getState()); 13416 enterRule(_localctx, 130, RULE_paramTag); 13417 int _la; 13418 try { 13419 enterOuterAlt(_localctx, 1); 13420 { 13421 setState(1527); 13422 match(OPEN); 13423 setState(1528); 13424 match(PARAM_HTML_TAG_NAME); 13425 setState(1535); 13426 _errHandler.sync(this); 13427 _la = _input.LA(1); 13428 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { 13429 { 13430 setState(1533); 13431 switch (_input.LA(1)) { 13432 case HTML_TAG_NAME: 13433 { 13434 setState(1529); 13435 attribute(); 13436 } 13437 break; 13438 case NEWLINE: 13439 { 13440 setState(1530); 13441 match(NEWLINE); 13442 } 13443 break; 13444 case LEADING_ASTERISK: 13445 { 13446 setState(1531); 13447 match(LEADING_ASTERISK); 13448 } 13449 break; 13450 case WS: 13451 { 13452 setState(1532); 13453 match(WS); 13454 } 13455 break; 13456 default: 13457 throw new NoViableAltException(this); 13458 } 13459 } 13460 setState(1537); 13461 _errHandler.sync(this); 13462 _la = _input.LA(1); 13463 } 13464 setState(1538); 13465 _la = _input.LA(1); 13466 if ( !(_la==CLOSE || _la==SLASH_CLOSE) ) { 13467 _errHandler.recoverInline(this); 13468 } else { 13469 consume(); 13470 } 13471 } 13472 } 13473 catch (RecognitionException re) { 13474 _localctx.exception = re; 13475 _errHandler.reportError(this, re); 13476 _errHandler.recover(this, re); 13477 } 13478 finally { 13479 exitRule(); 13480 } 13481 return _localctx; 13482 } 13483 13484 public static class WrongSinletonTagContext extends ParserRuleContext { 13485 public SingletonTagNameContext singletonTagName; 13486 public TerminalNode OPEN() { return getToken(JavadocParser.OPEN, 0); } 13487 public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } 13488 public SingletonTagNameContext singletonTagName() { 13489 return getRuleContext(SingletonTagNameContext.class,0); 13490 } 13491 public TerminalNode CLOSE() { return getToken(JavadocParser.CLOSE, 0); } 13492 public WrongSinletonTagContext(ParserRuleContext parent, int invokingState) { 13493 super(parent, invokingState); 13494 } 13495 @Override public int getRuleIndex() { return RULE_wrongSinletonTag; } 13496 @Override 13497 public void enterRule(ParseTreeListener listener) { 13498 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterWrongSinletonTag(this); 13499 } 13500 @Override 13501 public void exitRule(ParseTreeListener listener) { 13502 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitWrongSinletonTag(this); 13503 } 13504 @Override 13505 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13506 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWrongSinletonTag(this); 13507 else return visitor.visitChildren(this); 13508 } 13509 } 13510 13511 public final WrongSinletonTagContext wrongSinletonTag() throws RecognitionException { 13512 WrongSinletonTagContext _localctx = new WrongSinletonTagContext(_ctx, getState()); 13513 enterRule(_localctx, 132, RULE_wrongSinletonTag); 13514 try { 13515 enterOuterAlt(_localctx, 1); 13516 { 13517 setState(1540); 13518 match(OPEN); 13519 setState(1541); 13520 match(SLASH); 13521 setState(1542); 13522 ((WrongSinletonTagContext)_localctx).singletonTagName = singletonTagName(); 13523 setState(1543); 13524 match(CLOSE); 13525 notifyErrorListeners((((WrongSinletonTagContext)_localctx).singletonTagName!=null?(((WrongSinletonTagContext)_localctx).singletonTagName.start):null), 13526 "javadoc.wrong.singleton.html.tag", null); 13527 } 13528 } 13529 catch (RecognitionException re) { 13530 _localctx.exception = re; 13531 _errHandler.reportError(this, re); 13532 _errHandler.recover(this, re); 13533 } 13534 finally { 13535 exitRule(); 13536 } 13537 return _localctx; 13538 } 13539 13540 public static class SingletonTagNameContext extends ParserRuleContext { 13541 public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } 13542 public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } 13543 public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } 13544 public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } 13545 public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } 13546 public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } 13547 public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } 13548 public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } 13549 public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } 13550 public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } 13551 public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } 13552 public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } 13553 public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } 13554 public SingletonTagNameContext(ParserRuleContext parent, int invokingState) { 13555 super(parent, invokingState); 13556 } 13557 @Override public int getRuleIndex() { return RULE_singletonTagName; } 13558 @Override 13559 public void enterRule(ParseTreeListener listener) { 13560 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterSingletonTagName(this); 13561 } 13562 @Override 13563 public void exitRule(ParseTreeListener listener) { 13564 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitSingletonTagName(this); 13565 } 13566 @Override 13567 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13568 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTagName(this); 13569 else return visitor.visitChildren(this); 13570 } 13571 } 13572 13573 public final SingletonTagNameContext singletonTagName() throws RecognitionException { 13574 SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState()); 13575 enterRule(_localctx, 134, RULE_singletonTagName); 13576 int _la; 13577 try { 13578 enterOuterAlt(_localctx, 1); 13579 { 13580 setState(1546); 13581 _la = _input.LA(1); 13582 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)) ) { 13583 _errHandler.recoverInline(this); 13584 } else { 13585 consume(); 13586 } 13587 } 13588 } 13589 catch (RecognitionException re) { 13590 _localctx.exception = re; 13591 _errHandler.reportError(this, re); 13592 _errHandler.recover(this, re); 13593 } 13594 finally { 13595 exitRule(); 13596 } 13597 return _localctx; 13598 } 13599 13600 public static class DescriptionContext extends ParserRuleContext { 13601 public List<HtmlCommentContext> htmlComment() { 13602 return getRuleContexts(HtmlCommentContext.class); 13603 } 13604 public HtmlCommentContext htmlComment(int i) { 13605 return getRuleContext(HtmlCommentContext.class,i); 13606 } 13607 public List<TerminalNode> CDATA() { return getTokens(JavadocParser.CDATA); } 13608 public TerminalNode CDATA(int i) { 13609 return getToken(JavadocParser.CDATA, i); 13610 } 13611 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13612 public TerminalNode NEWLINE(int i) { 13613 return getToken(JavadocParser.NEWLINE, i); 13614 } 13615 public List<TextContext> text() { 13616 return getRuleContexts(TextContext.class); 13617 } 13618 public TextContext text(int i) { 13619 return getRuleContext(TextContext.class,i); 13620 } 13621 public List<JavadocInlineTagContext> javadocInlineTag() { 13622 return getRuleContexts(JavadocInlineTagContext.class); 13623 } 13624 public JavadocInlineTagContext javadocInlineTag(int i) { 13625 return getRuleContext(JavadocInlineTagContext.class,i); 13626 } 13627 public List<HtmlElementContext> htmlElement() { 13628 return getRuleContexts(HtmlElementContext.class); 13629 } 13630 public HtmlElementContext htmlElement(int i) { 13631 return getRuleContext(HtmlElementContext.class,i); 13632 } 13633 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13634 public TerminalNode LEADING_ASTERISK(int i) { 13635 return getToken(JavadocParser.LEADING_ASTERISK, i); 13636 } 13637 public DescriptionContext(ParserRuleContext parent, int invokingState) { 13638 super(parent, invokingState); 13639 } 13640 @Override public int getRuleIndex() { return RULE_description; } 13641 @Override 13642 public void enterRule(ParseTreeListener listener) { 13643 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterDescription(this); 13644 } 13645 @Override 13646 public void exitRule(ParseTreeListener listener) { 13647 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitDescription(this); 13648 } 13649 @Override 13650 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13651 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this); 13652 else return visitor.visitChildren(this); 13653 } 13654 } 13655 13656 public final DescriptionContext description() throws RecognitionException { 13657 DescriptionContext _localctx = new DescriptionContext(_ctx, getState()); 13658 enterRule(_localctx, 136, RULE_description); 13659 try { 13660 int _alt; 13661 enterOuterAlt(_localctx, 1); 13662 { 13663 setState(1556); 13664 _errHandler.sync(this); 13665 _alt = 1; 13666 do { 13667 switch (_alt) { 13668 case 1: 13669 { 13670 setState(1556); 13671 _errHandler.sync(this); 13672 switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) { 13673 case 1: 13674 { 13675 { 13676 setState(1548); 13677 if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); 13678 setState(1549); 13679 match(LEADING_ASTERISK); 13680 } 13681 } 13682 break; 13683 case 2: 13684 { 13685 setState(1550); 13686 htmlComment(); 13687 } 13688 break; 13689 case 3: 13690 { 13691 setState(1551); 13692 match(CDATA); 13693 } 13694 break; 13695 case 4: 13696 { 13697 setState(1552); 13698 match(NEWLINE); 13699 } 13700 break; 13701 case 5: 13702 { 13703 setState(1553); 13704 text(); 13705 } 13706 break; 13707 case 6: 13708 { 13709 setState(1554); 13710 javadocInlineTag(); 13711 } 13712 break; 13713 case 7: 13714 { 13715 setState(1555); 13716 htmlElement(); 13717 } 13718 break; 13719 } 13720 } 13721 break; 13722 default: 13723 throw new NoViableAltException(this); 13724 } 13725 setState(1558); 13726 _errHandler.sync(this); 13727 _alt = getInterpreter().adaptivePredict(_input,122,_ctx); 13728 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13729 } 13730 } 13731 catch (RecognitionException re) { 13732 _localctx.exception = re; 13733 _errHandler.reportError(this, re); 13734 _errHandler.recover(this, re); 13735 } 13736 finally { 13737 exitRule(); 13738 } 13739 return _localctx; 13740 } 13741 13742 public static class ReferenceContext extends ParserRuleContext { 13743 public TerminalNode PACKAGE() { return getToken(JavadocParser.PACKAGE, 0); } 13744 public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); } 13745 public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); } 13746 public ParametersContext parameters() { 13747 return getRuleContext(ParametersContext.class,0); 13748 } 13749 public List<TerminalNode> DOT() { return getTokens(JavadocParser.DOT); } 13750 public TerminalNode DOT(int i) { 13751 return getToken(JavadocParser.DOT, i); 13752 } 13753 public List<TerminalNode> CLASS() { return getTokens(JavadocParser.CLASS); } 13754 public TerminalNode CLASS(int i) { 13755 return getToken(JavadocParser.CLASS, i); 13756 } 13757 public ReferenceContext(ParserRuleContext parent, int invokingState) { 13758 super(parent, invokingState); 13759 } 13760 @Override public int getRuleIndex() { return RULE_reference; } 13761 @Override 13762 public void enterRule(ParseTreeListener listener) { 13763 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterReference(this); 13764 } 13765 @Override 13766 public void exitRule(ParseTreeListener listener) { 13767 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitReference(this); 13768 } 13769 @Override 13770 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13771 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitReference(this); 13772 else return visitor.visitChildren(this); 13773 } 13774 } 13775 13776 public final ReferenceContext reference() throws RecognitionException { 13777 ReferenceContext _localctx = new ReferenceContext(_ctx, getState()); 13778 enterRule(_localctx, 138, RULE_reference); 13779 int _la; 13780 try { 13781 int _alt; 13782 enterOuterAlt(_localctx, 1); 13783 { 13784 setState(1597); 13785 switch (_input.LA(1)) { 13786 case PACKAGE: 13787 { 13788 setState(1560); 13789 match(PACKAGE); 13790 setState(1564); 13791 _errHandler.sync(this); 13792 _alt = getInterpreter().adaptivePredict(_input,123,_ctx); 13793 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 13794 if ( _alt==1 ) { 13795 { 13796 { 13797 setState(1561); 13798 _la = _input.LA(1); 13799 if ( !(_la==DOT || _la==CLASS) ) { 13800 _errHandler.recoverInline(this); 13801 } else { 13802 consume(); 13803 } 13804 } 13805 } 13806 } 13807 setState(1566); 13808 _errHandler.sync(this); 13809 _alt = getInterpreter().adaptivePredict(_input,123,_ctx); 13810 } 13811 setState(1568); 13812 _errHandler.sync(this); 13813 switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) { 13814 case 1: 13815 { 13816 setState(1567); 13817 match(HASH); 13818 } 13819 break; 13820 } 13821 setState(1571); 13822 _errHandler.sync(this); 13823 switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) { 13824 case 1: 13825 { 13826 setState(1570); 13827 match(MEMBER); 13828 } 13829 break; 13830 } 13831 setState(1574); 13832 _errHandler.sync(this); 13833 switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) { 13834 case 1: 13835 { 13836 setState(1573); 13837 parameters(); 13838 } 13839 break; 13840 } 13841 } 13842 break; 13843 case DOT: 13844 case CLASS: 13845 { 13846 setState(1577); 13847 _errHandler.sync(this); 13848 _alt = 1; 13849 do { 13850 switch (_alt) { 13851 case 1: 13852 { 13853 { 13854 setState(1576); 13855 _la = _input.LA(1); 13856 if ( !(_la==DOT || _la==CLASS) ) { 13857 _errHandler.recoverInline(this); 13858 } else { 13859 consume(); 13860 } 13861 } 13862 } 13863 break; 13864 default: 13865 throw new NoViableAltException(this); 13866 } 13867 setState(1579); 13868 _errHandler.sync(this); 13869 _alt = getInterpreter().adaptivePredict(_input,127,_ctx); 13870 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 13871 setState(1582); 13872 _errHandler.sync(this); 13873 switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { 13874 case 1: 13875 { 13876 setState(1581); 13877 match(HASH); 13878 } 13879 break; 13880 } 13881 setState(1585); 13882 _errHandler.sync(this); 13883 switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) { 13884 case 1: 13885 { 13886 setState(1584); 13887 match(MEMBER); 13888 } 13889 break; 13890 } 13891 setState(1588); 13892 _errHandler.sync(this); 13893 switch ( getInterpreter().adaptivePredict(_input,130,_ctx) ) { 13894 case 1: 13895 { 13896 setState(1587); 13897 parameters(); 13898 } 13899 break; 13900 } 13901 } 13902 break; 13903 case HASH: 13904 case MEMBER: 13905 { 13906 setState(1591); 13907 _la = _input.LA(1); 13908 if (_la==HASH) { 13909 { 13910 setState(1590); 13911 match(HASH); 13912 } 13913 } 13914 13915 setState(1593); 13916 match(MEMBER); 13917 setState(1595); 13918 _errHandler.sync(this); 13919 switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { 13920 case 1: 13921 { 13922 setState(1594); 13923 parameters(); 13924 } 13925 break; 13926 } 13927 } 13928 break; 13929 default: 13930 throw new NoViableAltException(this); 13931 } 13932 } 13933 } 13934 catch (RecognitionException re) { 13935 _localctx.exception = re; 13936 _errHandler.reportError(this, re); 13937 _errHandler.recover(this, re); 13938 } 13939 finally { 13940 exitRule(); 13941 } 13942 return _localctx; 13943 } 13944 13945 public static class ParametersContext extends ParserRuleContext { 13946 public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); } 13947 public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); } 13948 public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); } 13949 public TerminalNode ARGUMENT(int i) { 13950 return getToken(JavadocParser.ARGUMENT, i); 13951 } 13952 public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); } 13953 public TerminalNode COMMA(int i) { 13954 return getToken(JavadocParser.COMMA, i); 13955 } 13956 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 13957 public TerminalNode WS(int i) { 13958 return getToken(JavadocParser.WS, i); 13959 } 13960 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 13961 public TerminalNode NEWLINE(int i) { 13962 return getToken(JavadocParser.NEWLINE, i); 13963 } 13964 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 13965 public TerminalNode LEADING_ASTERISK(int i) { 13966 return getToken(JavadocParser.LEADING_ASTERISK, i); 13967 } 13968 public ParametersContext(ParserRuleContext parent, int invokingState) { 13969 super(parent, invokingState); 13970 } 13971 @Override public int getRuleIndex() { return RULE_parameters; } 13972 @Override 13973 public void enterRule(ParseTreeListener listener) { 13974 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterParameters(this); 13975 } 13976 @Override 13977 public void exitRule(ParseTreeListener listener) { 13978 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitParameters(this); 13979 } 13980 @Override 13981 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 13982 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParameters(this); 13983 else return visitor.visitChildren(this); 13984 } 13985 } 13986 13987 public final ParametersContext parameters() throws RecognitionException { 13988 ParametersContext _localctx = new ParametersContext(_ctx, getState()); 13989 enterRule(_localctx, 140, RULE_parameters); 13990 int _la; 13991 try { 13992 enterOuterAlt(_localctx, 1); 13993 { 13994 setState(1599); 13995 match(LEFT_BRACE); 13996 setState(1603); 13997 _errHandler.sync(this); 13998 _la = _input.LA(1); 13999 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) { 14000 { 14001 { 14002 setState(1600); 14003 _la = _input.LA(1); 14004 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) { 14005 _errHandler.recoverInline(this); 14006 } else { 14007 consume(); 14008 } 14009 } 14010 } 14011 setState(1605); 14012 _errHandler.sync(this); 14013 _la = _input.LA(1); 14014 } 14015 setState(1606); 14016 match(RIGHT_BRACE); 14017 } 14018 } 14019 catch (RecognitionException re) { 14020 _localctx.exception = re; 14021 _errHandler.reportError(this, re); 14022 _errHandler.recover(this, re); 14023 } 14024 finally { 14025 exitRule(); 14026 } 14027 return _localctx; 14028 } 14029 14030 public static class JavadocTagContext extends ParserRuleContext { 14031 public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); } 14032 public DescriptionContext description() { 14033 return getRuleContext(DescriptionContext.class,0); 14034 } 14035 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14036 public TerminalNode WS(int i) { 14037 return getToken(JavadocParser.WS, i); 14038 } 14039 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14040 public TerminalNode NEWLINE(int i) { 14041 return getToken(JavadocParser.NEWLINE, i); 14042 } 14043 public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); } 14044 public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); } 14045 public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); } 14046 public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); } 14047 public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); } 14048 public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); } 14049 public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); } 14050 public ReferenceContext reference() { 14051 return getRuleContext(ReferenceContext.class,0); 14052 } 14053 public List<TerminalNode> STRING() { return getTokens(JavadocParser.STRING); } 14054 public TerminalNode STRING(int i) { 14055 return getToken(JavadocParser.STRING, i); 14056 } 14057 public List<HtmlElementContext> htmlElement() { 14058 return getRuleContexts(HtmlElementContext.class); 14059 } 14060 public HtmlElementContext htmlElement(int i) { 14061 return getRuleContext(HtmlElementContext.class,i); 14062 } 14063 public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); } 14064 public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); } 14065 public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); } 14066 public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); } 14067 public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); } 14068 public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); } 14069 public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); } 14070 public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); } 14071 public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); } 14072 public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); } 14073 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 14074 public JavadocTagContext(ParserRuleContext parent, int invokingState) { 14075 super(parent, invokingState); 14076 } 14077 @Override public int getRuleIndex() { return RULE_javadocTag; } 14078 @Override 14079 public void enterRule(ParseTreeListener listener) { 14080 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocTag(this); 14081 } 14082 @Override 14083 public void exitRule(ParseTreeListener listener) { 14084 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocTag(this); 14085 } 14086 @Override 14087 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14088 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocTag(this); 14089 else return visitor.visitChildren(this); 14090 } 14091 } 14092 14093 public final JavadocTagContext javadocTag() throws RecognitionException { 14094 JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState()); 14095 enterRule(_localctx, 142, RULE_javadocTag); 14096 int _la; 14097 try { 14098 int _alt; 14099 setState(1802); 14100 switch (_input.LA(1)) { 14101 case AUTHOR_LITERAL: 14102 enterOuterAlt(_localctx, 1); 14103 { 14104 setState(1608); 14105 match(AUTHOR_LITERAL); 14106 setState(1612); 14107 _errHandler.sync(this); 14108 _alt = getInterpreter().adaptivePredict(_input,135,_ctx); 14109 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14110 if ( _alt==1 ) { 14111 { 14112 { 14113 setState(1609); 14114 _la = _input.LA(1); 14115 if ( !(_la==WS || _la==NEWLINE) ) { 14116 _errHandler.recoverInline(this); 14117 } else { 14118 consume(); 14119 } 14120 } 14121 } 14122 } 14123 setState(1614); 14124 _errHandler.sync(this); 14125 _alt = getInterpreter().adaptivePredict(_input,135,_ctx); 14126 } 14127 setState(1616); 14128 _errHandler.sync(this); 14129 switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) { 14130 case 1: 14131 { 14132 setState(1615); 14133 description(); 14134 } 14135 break; 14136 } 14137 } 14138 break; 14139 case DEPRECATED_LITERAL: 14140 enterOuterAlt(_localctx, 2); 14141 { 14142 setState(1618); 14143 match(DEPRECATED_LITERAL); 14144 setState(1622); 14145 _errHandler.sync(this); 14146 _alt = getInterpreter().adaptivePredict(_input,137,_ctx); 14147 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14148 if ( _alt==1 ) { 14149 { 14150 { 14151 setState(1619); 14152 _la = _input.LA(1); 14153 if ( !(_la==WS || _la==NEWLINE) ) { 14154 _errHandler.recoverInline(this); 14155 } else { 14156 consume(); 14157 } 14158 } 14159 } 14160 } 14161 setState(1624); 14162 _errHandler.sync(this); 14163 _alt = getInterpreter().adaptivePredict(_input,137,_ctx); 14164 } 14165 setState(1626); 14166 _errHandler.sync(this); 14167 switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { 14168 case 1: 14169 { 14170 setState(1625); 14171 description(); 14172 } 14173 break; 14174 } 14175 } 14176 break; 14177 case EXCEPTION_LITERAL: 14178 enterOuterAlt(_localctx, 3); 14179 { 14180 setState(1628); 14181 match(EXCEPTION_LITERAL); 14182 setState(1632); 14183 _errHandler.sync(this); 14184 _alt = getInterpreter().adaptivePredict(_input,139,_ctx); 14185 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14186 if ( _alt==1 ) { 14187 { 14188 { 14189 setState(1629); 14190 _la = _input.LA(1); 14191 if ( !(_la==WS || _la==NEWLINE) ) { 14192 _errHandler.recoverInline(this); 14193 } else { 14194 consume(); 14195 } 14196 } 14197 } 14198 } 14199 setState(1634); 14200 _errHandler.sync(this); 14201 _alt = getInterpreter().adaptivePredict(_input,139,_ctx); 14202 } 14203 setState(1636); 14204 _errHandler.sync(this); 14205 switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) { 14206 case 1: 14207 { 14208 setState(1635); 14209 match(CLASS_NAME); 14210 } 14211 break; 14212 } 14213 setState(1641); 14214 _errHandler.sync(this); 14215 _alt = getInterpreter().adaptivePredict(_input,141,_ctx); 14216 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14217 if ( _alt==1 ) { 14218 { 14219 { 14220 setState(1638); 14221 _la = _input.LA(1); 14222 if ( !(_la==WS || _la==NEWLINE) ) { 14223 _errHandler.recoverInline(this); 14224 } else { 14225 consume(); 14226 } 14227 } 14228 } 14229 } 14230 setState(1643); 14231 _errHandler.sync(this); 14232 _alt = getInterpreter().adaptivePredict(_input,141,_ctx); 14233 } 14234 setState(1645); 14235 _errHandler.sync(this); 14236 switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) { 14237 case 1: 14238 { 14239 setState(1644); 14240 description(); 14241 } 14242 break; 14243 } 14244 } 14245 break; 14246 case PARAM_LITERAL: 14247 enterOuterAlt(_localctx, 4); 14248 { 14249 setState(1647); 14250 match(PARAM_LITERAL); 14251 setState(1651); 14252 _errHandler.sync(this); 14253 _alt = getInterpreter().adaptivePredict(_input,143,_ctx); 14254 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14255 if ( _alt==1 ) { 14256 { 14257 { 14258 setState(1648); 14259 _la = _input.LA(1); 14260 if ( !(_la==WS || _la==NEWLINE) ) { 14261 _errHandler.recoverInline(this); 14262 } else { 14263 consume(); 14264 } 14265 } 14266 } 14267 } 14268 setState(1653); 14269 _errHandler.sync(this); 14270 _alt = getInterpreter().adaptivePredict(_input,143,_ctx); 14271 } 14272 setState(1655); 14273 _errHandler.sync(this); 14274 switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { 14275 case 1: 14276 { 14277 setState(1654); 14278 match(PARAMETER_NAME); 14279 } 14280 break; 14281 } 14282 setState(1660); 14283 _errHandler.sync(this); 14284 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 14285 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14286 if ( _alt==1 ) { 14287 { 14288 { 14289 setState(1657); 14290 _la = _input.LA(1); 14291 if ( !(_la==WS || _la==NEWLINE) ) { 14292 _errHandler.recoverInline(this); 14293 } else { 14294 consume(); 14295 } 14296 } 14297 } 14298 } 14299 setState(1662); 14300 _errHandler.sync(this); 14301 _alt = getInterpreter().adaptivePredict(_input,145,_ctx); 14302 } 14303 setState(1664); 14304 _errHandler.sync(this); 14305 switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { 14306 case 1: 14307 { 14308 setState(1663); 14309 description(); 14310 } 14311 break; 14312 } 14313 } 14314 break; 14315 case RETURN_LITERAL: 14316 enterOuterAlt(_localctx, 5); 14317 { 14318 setState(1666); 14319 match(RETURN_LITERAL); 14320 setState(1670); 14321 _errHandler.sync(this); 14322 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 14323 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14324 if ( _alt==1 ) { 14325 { 14326 { 14327 setState(1667); 14328 _la = _input.LA(1); 14329 if ( !(_la==WS || _la==NEWLINE) ) { 14330 _errHandler.recoverInline(this); 14331 } else { 14332 consume(); 14333 } 14334 } 14335 } 14336 } 14337 setState(1672); 14338 _errHandler.sync(this); 14339 _alt = getInterpreter().adaptivePredict(_input,147,_ctx); 14340 } 14341 setState(1674); 14342 _errHandler.sync(this); 14343 switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { 14344 case 1: 14345 { 14346 setState(1673); 14347 description(); 14348 } 14349 break; 14350 } 14351 } 14352 break; 14353 case SEE_LITERAL: 14354 enterOuterAlt(_localctx, 6); 14355 { 14356 setState(1676); 14357 match(SEE_LITERAL); 14358 setState(1680); 14359 _errHandler.sync(this); 14360 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 14361 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14362 if ( _alt==1 ) { 14363 { 14364 { 14365 setState(1677); 14366 _la = _input.LA(1); 14367 if ( !(_la==WS || _la==NEWLINE) ) { 14368 _errHandler.recoverInline(this); 14369 } else { 14370 consume(); 14371 } 14372 } 14373 } 14374 } 14375 setState(1682); 14376 _errHandler.sync(this); 14377 _alt = getInterpreter().adaptivePredict(_input,149,_ctx); 14378 } 14379 setState(1684); 14380 _errHandler.sync(this); 14381 switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { 14382 case 1: 14383 { 14384 setState(1683); 14385 reference(); 14386 } 14387 break; 14388 } 14389 setState(1690); 14390 _errHandler.sync(this); 14391 _alt = getInterpreter().adaptivePredict(_input,152,_ctx); 14392 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14393 if ( _alt==1 ) { 14394 { 14395 setState(1688); 14396 switch (_input.LA(1)) { 14397 case STRING: 14398 { 14399 setState(1686); 14400 match(STRING); 14401 } 14402 break; 14403 case OPEN: 14404 { 14405 setState(1687); 14406 htmlElement(); 14407 } 14408 break; 14409 default: 14410 throw new NoViableAltException(this); 14411 } 14412 } 14413 } 14414 setState(1692); 14415 _errHandler.sync(this); 14416 _alt = getInterpreter().adaptivePredict(_input,152,_ctx); 14417 } 14418 setState(1696); 14419 _errHandler.sync(this); 14420 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 14421 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14422 if ( _alt==1 ) { 14423 { 14424 { 14425 setState(1693); 14426 _la = _input.LA(1); 14427 if ( !(_la==WS || _la==NEWLINE) ) { 14428 _errHandler.recoverInline(this); 14429 } else { 14430 consume(); 14431 } 14432 } 14433 } 14434 } 14435 setState(1698); 14436 _errHandler.sync(this); 14437 _alt = getInterpreter().adaptivePredict(_input,153,_ctx); 14438 } 14439 setState(1700); 14440 _errHandler.sync(this); 14441 switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { 14442 case 1: 14443 { 14444 setState(1699); 14445 description(); 14446 } 14447 break; 14448 } 14449 } 14450 break; 14451 case SERIAL_LITERAL: 14452 enterOuterAlt(_localctx, 7); 14453 { 14454 setState(1702); 14455 match(SERIAL_LITERAL); 14456 setState(1706); 14457 _errHandler.sync(this); 14458 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 14459 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14460 if ( _alt==1 ) { 14461 { 14462 { 14463 setState(1703); 14464 _la = _input.LA(1); 14465 if ( !(_la==WS || _la==NEWLINE) ) { 14466 _errHandler.recoverInline(this); 14467 } else { 14468 consume(); 14469 } 14470 } 14471 } 14472 } 14473 setState(1708); 14474 _errHandler.sync(this); 14475 _alt = getInterpreter().adaptivePredict(_input,155,_ctx); 14476 } 14477 setState(1710); 14478 _errHandler.sync(this); 14479 switch ( getInterpreter().adaptivePredict(_input,156,_ctx) ) { 14480 case 1: 14481 { 14482 setState(1709); 14483 _la = _input.LA(1); 14484 if ( !(_la==LITERAL_INCLUDE || _la==LITERAL_EXCLUDE) ) { 14485 _errHandler.recoverInline(this); 14486 } else { 14487 consume(); 14488 } 14489 } 14490 break; 14491 } 14492 setState(1713); 14493 _errHandler.sync(this); 14494 switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { 14495 case 1: 14496 { 14497 setState(1712); 14498 description(); 14499 } 14500 break; 14501 } 14502 } 14503 break; 14504 case SERIAL_DATA_LITERAL: 14505 enterOuterAlt(_localctx, 8); 14506 { 14507 setState(1715); 14508 match(SERIAL_DATA_LITERAL); 14509 setState(1719); 14510 _errHandler.sync(this); 14511 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14512 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14513 if ( _alt==1 ) { 14514 { 14515 { 14516 setState(1716); 14517 _la = _input.LA(1); 14518 if ( !(_la==WS || _la==NEWLINE) ) { 14519 _errHandler.recoverInline(this); 14520 } else { 14521 consume(); 14522 } 14523 } 14524 } 14525 } 14526 setState(1721); 14527 _errHandler.sync(this); 14528 _alt = getInterpreter().adaptivePredict(_input,158,_ctx); 14529 } 14530 setState(1723); 14531 _errHandler.sync(this); 14532 switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) { 14533 case 1: 14534 { 14535 setState(1722); 14536 description(); 14537 } 14538 break; 14539 } 14540 } 14541 break; 14542 case SERIAL_FIELD_LITERAL: 14543 enterOuterAlt(_localctx, 9); 14544 { 14545 setState(1725); 14546 match(SERIAL_FIELD_LITERAL); 14547 setState(1729); 14548 _errHandler.sync(this); 14549 _alt = getInterpreter().adaptivePredict(_input,160,_ctx); 14550 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14551 if ( _alt==1 ) { 14552 { 14553 { 14554 setState(1726); 14555 _la = _input.LA(1); 14556 if ( !(_la==WS || _la==NEWLINE) ) { 14557 _errHandler.recoverInline(this); 14558 } else { 14559 consume(); 14560 } 14561 } 14562 } 14563 } 14564 setState(1731); 14565 _errHandler.sync(this); 14566 _alt = getInterpreter().adaptivePredict(_input,160,_ctx); 14567 } 14568 setState(1733); 14569 _errHandler.sync(this); 14570 switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) { 14571 case 1: 14572 { 14573 setState(1732); 14574 match(FIELD_NAME); 14575 } 14576 break; 14577 } 14578 setState(1738); 14579 _errHandler.sync(this); 14580 _alt = getInterpreter().adaptivePredict(_input,162,_ctx); 14581 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14582 if ( _alt==1 ) { 14583 { 14584 { 14585 setState(1735); 14586 _la = _input.LA(1); 14587 if ( !(_la==WS || _la==NEWLINE) ) { 14588 _errHandler.recoverInline(this); 14589 } else { 14590 consume(); 14591 } 14592 } 14593 } 14594 } 14595 setState(1740); 14596 _errHandler.sync(this); 14597 _alt = getInterpreter().adaptivePredict(_input,162,_ctx); 14598 } 14599 setState(1742); 14600 _errHandler.sync(this); 14601 switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) { 14602 case 1: 14603 { 14604 setState(1741); 14605 match(FIELD_TYPE); 14606 } 14607 break; 14608 } 14609 setState(1747); 14610 _errHandler.sync(this); 14611 _alt = getInterpreter().adaptivePredict(_input,164,_ctx); 14612 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14613 if ( _alt==1 ) { 14614 { 14615 { 14616 setState(1744); 14617 _la = _input.LA(1); 14618 if ( !(_la==WS || _la==NEWLINE) ) { 14619 _errHandler.recoverInline(this); 14620 } else { 14621 consume(); 14622 } 14623 } 14624 } 14625 } 14626 setState(1749); 14627 _errHandler.sync(this); 14628 _alt = getInterpreter().adaptivePredict(_input,164,_ctx); 14629 } 14630 setState(1751); 14631 _errHandler.sync(this); 14632 switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) { 14633 case 1: 14634 { 14635 setState(1750); 14636 description(); 14637 } 14638 break; 14639 } 14640 } 14641 break; 14642 case SINCE_LITERAL: 14643 enterOuterAlt(_localctx, 10); 14644 { 14645 setState(1753); 14646 match(SINCE_LITERAL); 14647 setState(1757); 14648 _errHandler.sync(this); 14649 _alt = getInterpreter().adaptivePredict(_input,166,_ctx); 14650 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14651 if ( _alt==1 ) { 14652 { 14653 { 14654 setState(1754); 14655 _la = _input.LA(1); 14656 if ( !(_la==WS || _la==NEWLINE) ) { 14657 _errHandler.recoverInline(this); 14658 } else { 14659 consume(); 14660 } 14661 } 14662 } 14663 } 14664 setState(1759); 14665 _errHandler.sync(this); 14666 _alt = getInterpreter().adaptivePredict(_input,166,_ctx); 14667 } 14668 setState(1761); 14669 _errHandler.sync(this); 14670 switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { 14671 case 1: 14672 { 14673 setState(1760); 14674 description(); 14675 } 14676 break; 14677 } 14678 } 14679 break; 14680 case THROWS_LITERAL: 14681 enterOuterAlt(_localctx, 11); 14682 { 14683 setState(1763); 14684 match(THROWS_LITERAL); 14685 setState(1767); 14686 _errHandler.sync(this); 14687 _alt = getInterpreter().adaptivePredict(_input,168,_ctx); 14688 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14689 if ( _alt==1 ) { 14690 { 14691 { 14692 setState(1764); 14693 _la = _input.LA(1); 14694 if ( !(_la==WS || _la==NEWLINE) ) { 14695 _errHandler.recoverInline(this); 14696 } else { 14697 consume(); 14698 } 14699 } 14700 } 14701 } 14702 setState(1769); 14703 _errHandler.sync(this); 14704 _alt = getInterpreter().adaptivePredict(_input,168,_ctx); 14705 } 14706 setState(1771); 14707 _errHandler.sync(this); 14708 switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) { 14709 case 1: 14710 { 14711 setState(1770); 14712 match(CLASS_NAME); 14713 } 14714 break; 14715 } 14716 setState(1776); 14717 _errHandler.sync(this); 14718 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14719 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14720 if ( _alt==1 ) { 14721 { 14722 { 14723 setState(1773); 14724 _la = _input.LA(1); 14725 if ( !(_la==WS || _la==NEWLINE) ) { 14726 _errHandler.recoverInline(this); 14727 } else { 14728 consume(); 14729 } 14730 } 14731 } 14732 } 14733 setState(1778); 14734 _errHandler.sync(this); 14735 _alt = getInterpreter().adaptivePredict(_input,170,_ctx); 14736 } 14737 setState(1780); 14738 _errHandler.sync(this); 14739 switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) { 14740 case 1: 14741 { 14742 setState(1779); 14743 description(); 14744 } 14745 break; 14746 } 14747 } 14748 break; 14749 case VERSION_LITERAL: 14750 enterOuterAlt(_localctx, 12); 14751 { 14752 setState(1782); 14753 match(VERSION_LITERAL); 14754 setState(1786); 14755 _errHandler.sync(this); 14756 _alt = getInterpreter().adaptivePredict(_input,172,_ctx); 14757 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14758 if ( _alt==1 ) { 14759 { 14760 { 14761 setState(1783); 14762 _la = _input.LA(1); 14763 if ( !(_la==WS || _la==NEWLINE) ) { 14764 _errHandler.recoverInline(this); 14765 } else { 14766 consume(); 14767 } 14768 } 14769 } 14770 } 14771 setState(1788); 14772 _errHandler.sync(this); 14773 _alt = getInterpreter().adaptivePredict(_input,172,_ctx); 14774 } 14775 setState(1790); 14776 _errHandler.sync(this); 14777 switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) { 14778 case 1: 14779 { 14780 setState(1789); 14781 description(); 14782 } 14783 break; 14784 } 14785 } 14786 break; 14787 case CUSTOM_NAME: 14788 enterOuterAlt(_localctx, 13); 14789 { 14790 setState(1792); 14791 match(CUSTOM_NAME); 14792 setState(1796); 14793 _errHandler.sync(this); 14794 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 14795 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 14796 if ( _alt==1 ) { 14797 { 14798 { 14799 setState(1793); 14800 _la = _input.LA(1); 14801 if ( !(_la==WS || _la==NEWLINE) ) { 14802 _errHandler.recoverInline(this); 14803 } else { 14804 consume(); 14805 } 14806 } 14807 } 14808 } 14809 setState(1798); 14810 _errHandler.sync(this); 14811 _alt = getInterpreter().adaptivePredict(_input,174,_ctx); 14812 } 14813 setState(1800); 14814 _errHandler.sync(this); 14815 switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) { 14816 case 1: 14817 { 14818 setState(1799); 14819 description(); 14820 } 14821 break; 14822 } 14823 } 14824 break; 14825 default: 14826 throw new NoViableAltException(this); 14827 } 14828 } 14829 catch (RecognitionException re) { 14830 _localctx.exception = re; 14831 _errHandler.reportError(this, re); 14832 _errHandler.recover(this, re); 14833 } 14834 finally { 14835 exitRule(); 14836 } 14837 return _localctx; 14838 } 14839 14840 public static class JavadocInlineTagContext extends ParserRuleContext { 14841 public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); } 14842 public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); } 14843 public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); } 14844 public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); } 14845 public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); } 14846 public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); } 14847 public ReferenceContext reference() { 14848 return getRuleContext(ReferenceContext.class,0); 14849 } 14850 public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); } 14851 public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); } 14852 public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); } 14853 public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } 14854 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 14855 public TerminalNode WS(int i) { 14856 return getToken(JavadocParser.WS, i); 14857 } 14858 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 14859 public TerminalNode NEWLINE(int i) { 14860 return getToken(JavadocParser.NEWLINE, i); 14861 } 14862 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 14863 public TerminalNode LEADING_ASTERISK(int i) { 14864 return getToken(JavadocParser.LEADING_ASTERISK, i); 14865 } 14866 public List<TextContext> text() { 14867 return getRuleContexts(TextContext.class); 14868 } 14869 public TextContext text(int i) { 14870 return getRuleContext(TextContext.class,i); 14871 } 14872 public DescriptionContext description() { 14873 return getRuleContext(DescriptionContext.class,0); 14874 } 14875 public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) { 14876 super(parent, invokingState); 14877 } 14878 @Override public int getRuleIndex() { return RULE_javadocInlineTag; } 14879 @Override 14880 public void enterRule(ParseTreeListener listener) { 14881 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterJavadocInlineTag(this); 14882 } 14883 @Override 14884 public void exitRule(ParseTreeListener listener) { 14885 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitJavadocInlineTag(this); 14886 } 14887 @Override 14888 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 14889 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocInlineTag(this); 14890 else return visitor.visitChildren(this); 14891 } 14892 } 14893 14894 public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException { 14895 JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState()); 14896 enterRule(_localctx, 144, RULE_javadocInlineTag); 14897 int _la; 14898 try { 14899 int _alt; 14900 enterOuterAlt(_localctx, 1); 14901 { 14902 setState(1804); 14903 match(JAVADOC_INLINE_TAG_START); 14904 setState(1881); 14905 switch (_input.LA(1)) { 14906 case CODE_LITERAL: 14907 { 14908 setState(1805); 14909 match(CODE_LITERAL); 14910 setState(1812); 14911 _errHandler.sync(this); 14912 _la = _input.LA(1); 14913 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 14914 { 14915 setState(1810); 14916 _errHandler.sync(this); 14917 switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) { 14918 case 1: 14919 { 14920 setState(1806); 14921 match(WS); 14922 } 14923 break; 14924 case 2: 14925 { 14926 setState(1807); 14927 match(NEWLINE); 14928 } 14929 break; 14930 case 3: 14931 { 14932 setState(1808); 14933 match(LEADING_ASTERISK); 14934 } 14935 break; 14936 case 4: 14937 { 14938 setState(1809); 14939 text(); 14940 } 14941 break; 14942 } 14943 } 14944 setState(1814); 14945 _errHandler.sync(this); 14946 _la = _input.LA(1); 14947 } 14948 } 14949 break; 14950 case DOC_ROOT_LITERAL: 14951 { 14952 setState(1815); 14953 match(DOC_ROOT_LITERAL); 14954 setState(1819); 14955 _errHandler.sync(this); 14956 _la = _input.LA(1); 14957 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 14958 { 14959 { 14960 setState(1816); 14961 _la = _input.LA(1); 14962 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14963 _errHandler.recoverInline(this); 14964 } else { 14965 consume(); 14966 } 14967 } 14968 } 14969 setState(1821); 14970 _errHandler.sync(this); 14971 _la = _input.LA(1); 14972 } 14973 } 14974 break; 14975 case INHERIT_DOC_LITERAL: 14976 { 14977 setState(1822); 14978 match(INHERIT_DOC_LITERAL); 14979 setState(1826); 14980 _errHandler.sync(this); 14981 _la = _input.LA(1); 14982 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 14983 { 14984 { 14985 setState(1823); 14986 _la = _input.LA(1); 14987 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 14988 _errHandler.recoverInline(this); 14989 } else { 14990 consume(); 14991 } 14992 } 14993 } 14994 setState(1828); 14995 _errHandler.sync(this); 14996 _la = _input.LA(1); 14997 } 14998 } 14999 break; 15000 case LINK_LITERAL: 15001 { 15002 setState(1829); 15003 match(LINK_LITERAL); 15004 setState(1833); 15005 _errHandler.sync(this); 15006 _la = _input.LA(1); 15007 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15008 { 15009 { 15010 setState(1830); 15011 _la = _input.LA(1); 15012 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15013 _errHandler.recoverInline(this); 15014 } else { 15015 consume(); 15016 } 15017 } 15018 } 15019 setState(1835); 15020 _errHandler.sync(this); 15021 _la = _input.LA(1); 15022 } 15023 setState(1836); 15024 reference(); 15025 setState(1838); 15026 _errHandler.sync(this); 15027 switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { 15028 case 1: 15029 { 15030 setState(1837); 15031 description(); 15032 } 15033 break; 15034 } 15035 } 15036 break; 15037 case LINKPLAIN_LITERAL: 15038 { 15039 setState(1840); 15040 match(LINKPLAIN_LITERAL); 15041 setState(1844); 15042 _errHandler.sync(this); 15043 _la = _input.LA(1); 15044 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15045 { 15046 { 15047 setState(1841); 15048 _la = _input.LA(1); 15049 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15050 _errHandler.recoverInline(this); 15051 } else { 15052 consume(); 15053 } 15054 } 15055 } 15056 setState(1846); 15057 _errHandler.sync(this); 15058 _la = _input.LA(1); 15059 } 15060 setState(1847); 15061 reference(); 15062 setState(1849); 15063 _errHandler.sync(this); 15064 switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) { 15065 case 1: 15066 { 15067 setState(1848); 15068 description(); 15069 } 15070 break; 15071 } 15072 } 15073 break; 15074 case LITERAL_LITERAL: 15075 { 15076 setState(1851); 15077 match(LITERAL_LITERAL); 15078 setState(1858); 15079 _errHandler.sync(this); 15080 _la = _input.LA(1); 15081 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15082 { 15083 setState(1856); 15084 _errHandler.sync(this); 15085 switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) { 15086 case 1: 15087 { 15088 setState(1852); 15089 match(WS); 15090 } 15091 break; 15092 case 2: 15093 { 15094 setState(1853); 15095 match(NEWLINE); 15096 } 15097 break; 15098 case 3: 15099 { 15100 setState(1854); 15101 match(LEADING_ASTERISK); 15102 } 15103 break; 15104 case 4: 15105 { 15106 setState(1855); 15107 text(); 15108 } 15109 break; 15110 } 15111 } 15112 setState(1860); 15113 _errHandler.sync(this); 15114 _la = _input.LA(1); 15115 } 15116 } 15117 break; 15118 case VALUE_LITERAL: 15119 { 15120 setState(1861); 15121 match(VALUE_LITERAL); 15122 setState(1865); 15123 _errHandler.sync(this); 15124 _la = _input.LA(1); 15125 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { 15126 { 15127 { 15128 setState(1862); 15129 _la = _input.LA(1); 15130 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15131 _errHandler.recoverInline(this); 15132 } else { 15133 consume(); 15134 } 15135 } 15136 } 15137 setState(1867); 15138 _errHandler.sync(this); 15139 _la = _input.LA(1); 15140 } 15141 setState(1869); 15142 _la = _input.LA(1); 15143 if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PACKAGE) | (1L << DOT) | (1L << HASH) | (1L << CLASS) | (1L << MEMBER))) != 0)) { 15144 { 15145 setState(1868); 15146 reference(); 15147 } 15148 } 15149 15150 } 15151 break; 15152 case CUSTOM_NAME: 15153 { 15154 setState(1871); 15155 match(CUSTOM_NAME); 15156 setState(1875); 15157 _errHandler.sync(this); 15158 _alt = getInterpreter().adaptivePredict(_input,189,_ctx); 15159 while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { 15160 if ( _alt==1 ) { 15161 { 15162 { 15163 setState(1872); 15164 _la = _input.LA(1); 15165 if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { 15166 _errHandler.recoverInline(this); 15167 } else { 15168 consume(); 15169 } 15170 } 15171 } 15172 } 15173 setState(1877); 15174 _errHandler.sync(this); 15175 _alt = getInterpreter().adaptivePredict(_input,189,_ctx); 15176 } 15177 setState(1879); 15178 _errHandler.sync(this); 15179 switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) { 15180 case 1: 15181 { 15182 setState(1878); 15183 description(); 15184 } 15185 break; 15186 } 15187 } 15188 break; 15189 default: 15190 throw new NoViableAltException(this); 15191 } 15192 setState(1883); 15193 match(JAVADOC_INLINE_TAG_END); 15194 } 15195 } 15196 catch (RecognitionException re) { 15197 _localctx.exception = re; 15198 _errHandler.reportError(this, re); 15199 _errHandler.recover(this, re); 15200 } 15201 finally { 15202 exitRule(); 15203 } 15204 return _localctx; 15205 } 15206 15207 public static class HtmlCommentContext extends ParserRuleContext { 15208 public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); } 15209 public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); } 15210 public List<TextContext> text() { 15211 return getRuleContexts(TextContext.class); 15212 } 15213 public TextContext text(int i) { 15214 return getRuleContext(TextContext.class,i); 15215 } 15216 public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } 15217 public TerminalNode NEWLINE(int i) { 15218 return getToken(JavadocParser.NEWLINE, i); 15219 } 15220 public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } 15221 public TerminalNode LEADING_ASTERISK(int i) { 15222 return getToken(JavadocParser.LEADING_ASTERISK, i); 15223 } 15224 public HtmlCommentContext(ParserRuleContext parent, int invokingState) { 15225 super(parent, invokingState); 15226 } 15227 @Override public int getRuleIndex() { return RULE_htmlComment; } 15228 @Override 15229 public void enterRule(ParseTreeListener listener) { 15230 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterHtmlComment(this); 15231 } 15232 @Override 15233 public void exitRule(ParseTreeListener listener) { 15234 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitHtmlComment(this); 15235 } 15236 @Override 15237 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15238 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlComment(this); 15239 else return visitor.visitChildren(this); 15240 } 15241 } 15242 15243 public final HtmlCommentContext htmlComment() throws RecognitionException { 15244 HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState()); 15245 enterRule(_localctx, 146, RULE_htmlComment); 15246 int _la; 15247 try { 15248 enterOuterAlt(_localctx, 1); 15249 { 15250 setState(1885); 15251 match(HTML_COMMENT_START); 15252 setState(1891); 15253 _errHandler.sync(this); 15254 _la = _input.LA(1); 15255 while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { 15256 { 15257 setState(1889); 15258 switch (_input.LA(1)) { 15259 case WS: 15260 case CHAR: 15261 { 15262 setState(1886); 15263 text(); 15264 } 15265 break; 15266 case NEWLINE: 15267 { 15268 setState(1887); 15269 match(NEWLINE); 15270 } 15271 break; 15272 case LEADING_ASTERISK: 15273 { 15274 setState(1888); 15275 match(LEADING_ASTERISK); 15276 } 15277 break; 15278 default: 15279 throw new NoViableAltException(this); 15280 } 15281 } 15282 setState(1893); 15283 _errHandler.sync(this); 15284 _la = _input.LA(1); 15285 } 15286 setState(1894); 15287 match(HTML_COMMENT_END); 15288 } 15289 } 15290 catch (RecognitionException re) { 15291 _localctx.exception = re; 15292 _errHandler.reportError(this, re); 15293 _errHandler.recover(this, re); 15294 } 15295 finally { 15296 exitRule(); 15297 } 15298 return _localctx; 15299 } 15300 15301 public static class TextContext extends ParserRuleContext { 15302 public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); } 15303 public TerminalNode CHAR(int i) { 15304 return getToken(JavadocParser.CHAR, i); 15305 } 15306 public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } 15307 public TerminalNode WS(int i) { 15308 return getToken(JavadocParser.WS, i); 15309 } 15310 public TextContext(ParserRuleContext parent, int invokingState) { 15311 super(parent, invokingState); 15312 } 15313 @Override public int getRuleIndex() { return RULE_text; } 15314 @Override 15315 public void enterRule(ParseTreeListener listener) { 15316 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).enterText(this); 15317 } 15318 @Override 15319 public void exitRule(ParseTreeListener listener) { 15320 if ( listener instanceof JavadocParserListener ) ((JavadocParserListener)listener).exitText(this); 15321 } 15322 @Override 15323 public <T> T accept(ParseTreeVisitor<? extends T> visitor) { 15324 if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitText(this); 15325 else return visitor.visitChildren(this); 15326 } 15327 } 15328 15329 public final TextContext text() throws RecognitionException { 15330 TextContext _localctx = new TextContext(_ctx, getState()); 15331 enterRule(_localctx, 148, RULE_text); 15332 int _la; 15333 try { 15334 int _alt; 15335 enterOuterAlt(_localctx, 1); 15336 { 15337 setState(1898); 15338 _errHandler.sync(this); 15339 _alt = 1; 15340 do { 15341 switch (_alt) { 15342 case 1: 15343 { 15344 { 15345 setState(1896); 15346 _la = _input.LA(1); 15347 if ( !(_la==WS || _la==CHAR) ) { 15348 _errHandler.recoverInline(this); 15349 } else { 15350 consume(); 15351 } 15352 15353 _la = _input.LA(1); 15354 if ((_la != WS) && (_la != CHAR)) return _localctx; 15355 else if (_alt == 1) continue; 15356 15357 } 15358 } 15359 break; 15360 default: 15361 throw new NoViableAltException(this); 15362 } 15363 setState(1900); 15364 _errHandler.sync(this); 15365 _alt = getInterpreter().adaptivePredict(_input,194,_ctx); 15366 } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); 15367 } 15368 } 15369 catch (RecognitionException re) { 15370 _localctx.exception = re; 15371 _errHandler.reportError(this, re); 15372 _errHandler.recover(this, re); 15373 } 15374 finally { 15375 exitRule(); 15376 } 15377 return _localctx; 15378 } 15379 15380 public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { 15381 switch (ruleIndex) { 15382 case 0: 15383 return javadoc_sempred((JavadocContext)_localctx, predIndex); 15384 case 5: 15385 return htmlTag_sempred((HtmlTagContext)_localctx, predIndex); 15386 case 8: 15387 return paragraph_sempred((ParagraphContext)_localctx, predIndex); 15388 case 11: 15389 return li_sempred((LiContext)_localctx, predIndex); 15390 case 14: 15391 return tr_sempred((TrContext)_localctx, predIndex); 15392 case 17: 15393 return td_sempred((TdContext)_localctx, predIndex); 15394 case 20: 15395 return th_sempred((ThContext)_localctx, predIndex); 15396 case 23: 15397 return body_sempred((BodyContext)_localctx, predIndex); 15398 case 26: 15399 return colgroup_sempred((ColgroupContext)_localctx, predIndex); 15400 case 29: 15401 return dd_sempred((DdContext)_localctx, predIndex); 15402 case 32: 15403 return dt_sempred((DtContext)_localctx, predIndex); 15404 case 35: 15405 return head_sempred((HeadContext)_localctx, predIndex); 15406 case 38: 15407 return html_sempred((HtmlContext)_localctx, predIndex); 15408 case 41: 15409 return option_sempred((OptionContext)_localctx, predIndex); 15410 case 44: 15411 return tbody_sempred((TbodyContext)_localctx, predIndex); 15412 case 47: 15413 return tfoot_sempred((TfootContext)_localctx, predIndex); 15414 case 50: 15415 return thead_sempred((TheadContext)_localctx, predIndex); 15416 case 68: 15417 return description_sempred((DescriptionContext)_localctx, predIndex); 15418 } 15419 return true; 15420 } 15421 private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) { 15422 switch (predIndex) { 15423 case 0: 15424 return !isNextJavadocTag(); 15425 } 15426 return true; 15427 } 15428 private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) { 15429 switch (predIndex) { 15430 case 1: 15431 return !isNextJavadocTag(); 15432 case 2: 15433 return !isNextJavadocTag(); 15434 } 15435 return true; 15436 } 15437 private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) { 15438 switch (predIndex) { 15439 case 3: 15440 return !isNextJavadocTag(); 15441 } 15442 return true; 15443 } 15444 private boolean li_sempred(LiContext _localctx, int predIndex) { 15445 switch (predIndex) { 15446 case 4: 15447 return !isNextJavadocTag(); 15448 } 15449 return true; 15450 } 15451 private boolean tr_sempred(TrContext _localctx, int predIndex) { 15452 switch (predIndex) { 15453 case 5: 15454 return !isNextJavadocTag(); 15455 } 15456 return true; 15457 } 15458 private boolean td_sempred(TdContext _localctx, int predIndex) { 15459 switch (predIndex) { 15460 case 6: 15461 return !isNextJavadocTag(); 15462 } 15463 return true; 15464 } 15465 private boolean th_sempred(ThContext _localctx, int predIndex) { 15466 switch (predIndex) { 15467 case 7: 15468 return !isNextJavadocTag(); 15469 } 15470 return true; 15471 } 15472 private boolean body_sempred(BodyContext _localctx, int predIndex) { 15473 switch (predIndex) { 15474 case 8: 15475 return !isNextJavadocTag(); 15476 } 15477 return true; 15478 } 15479 private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) { 15480 switch (predIndex) { 15481 case 9: 15482 return !isNextJavadocTag(); 15483 } 15484 return true; 15485 } 15486 private boolean dd_sempred(DdContext _localctx, int predIndex) { 15487 switch (predIndex) { 15488 case 10: 15489 return !isNextJavadocTag(); 15490 } 15491 return true; 15492 } 15493 private boolean dt_sempred(DtContext _localctx, int predIndex) { 15494 switch (predIndex) { 15495 case 11: 15496 return !isNextJavadocTag(); 15497 } 15498 return true; 15499 } 15500 private boolean head_sempred(HeadContext _localctx, int predIndex) { 15501 switch (predIndex) { 15502 case 12: 15503 return !isNextJavadocTag(); 15504 } 15505 return true; 15506 } 15507 private boolean html_sempred(HtmlContext _localctx, int predIndex) { 15508 switch (predIndex) { 15509 case 13: 15510 return !isNextJavadocTag(); 15511 } 15512 return true; 15513 } 15514 private boolean option_sempred(OptionContext _localctx, int predIndex) { 15515 switch (predIndex) { 15516 case 14: 15517 return !isNextJavadocTag(); 15518 } 15519 return true; 15520 } 15521 private boolean tbody_sempred(TbodyContext _localctx, int predIndex) { 15522 switch (predIndex) { 15523 case 15: 15524 return !isNextJavadocTag(); 15525 } 15526 return true; 15527 } 15528 private boolean tfoot_sempred(TfootContext _localctx, int predIndex) { 15529 switch (predIndex) { 15530 case 16: 15531 return !isNextJavadocTag(); 15532 } 15533 return true; 15534 } 15535 private boolean thead_sempred(TheadContext _localctx, int predIndex) { 15536 switch (predIndex) { 15537 case 17: 15538 return !isNextJavadocTag(); 15539 } 15540 return true; 15541 } 15542 private boolean description_sempred(DescriptionContext _localctx, int predIndex) { 15543 switch (predIndex) { 15544 case 18: 15545 return !isNextJavadocTag(); 15546 } 15547 return true; 15548 } 15549 15550 public static final String _serializedATN = 15551 "\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3]\u0771\4\2\t\2\4"+ 15552 "\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"+ 15553 "\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"+ 15554 "\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"+ 15555 "\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!"+ 15556 "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ 15557 ",\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"+ 15558 "\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="+ 15559 "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ 15560 "\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"+ 15561 "\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"+ 15562 "\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"+ 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\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3"+ 15565 "\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"+ 15566 "\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"+ 15567 "\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"+ 15568 "\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"+ 15569 "\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"+ 15570 "\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"+ 15571 "\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"+ 15572 "\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"+ 15573 "\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"+ 15574 "\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"+ 15575 "\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"+ 15576 "\13\3\13\3\13\3\13\3\13\3\13\7\13\u0180\n\13\f\13\16\13\u0183\13\13\3"+ 15577 "\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"+ 15578 "\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"+ 15579 "\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"+ 15580 "\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"+ 15581 "\3\16\3\16\7\16\u01c5\n\16\f\16\16\16\u01c8\13\16\3\16\3\16\3\17\3\17"+ 15582 "\3\17\3\17\7\17\u01d0\n\17\f\17\16\17\u01d3\13\17\3\17\3\17\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\3\20\3\20\3\20\3\20\3\20\3\20"+ 15585 "\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"+ 15586 "\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"+ 15587 "\21\u020d\13\21\3\21\3\21\3\22\3\22\3\22\3\22\7\22\u0215\n\22\f\22\16"+ 15588 "\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"+ 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\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"+ 15591 "\3\23\7\23\u0242\n\23\f\23\16\23\u0245\13\23\3\23\3\23\3\24\3\24\3\24"+ 15592 "\3\24\3\24\3\24\7\24\u024f\n\24\f\24\16\24\u0252\13\24\3\24\3\24\3\25"+ 15593 "\3\25\3\25\3\25\7\25\u025a\n\25\f\25\16\25\u025d\13\25\3\25\3\25\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\3\26\3\26\3\26\3\26\3\26"+ 15596 "\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"+ 15597 "\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"+ 15598 "\f\27\16\27\u0297\13\27\3\27\3\27\3\30\3\30\3\30\3\30\7\30\u029f\n\30"+ 15599 "\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"+ 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\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3"+ 15602 "\31\3\31\3\31\7\31\u02cc\n\31\f\31\16\31\u02cf\13\31\3\31\3\31\3\32\3"+ 15603 "\32\3\32\3\32\3\32\3\32\7\32\u02d9\n\32\f\32\16\32\u02dc\13\32\3\32\3"+ 15604 "\32\3\33\3\33\3\33\3\33\7\33\u02e4\n\33\f\33\16\33\u02e7\13\33\3\33\3"+ 15605 "\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"+ 15606 "\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"+ 15607 "\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"+ 15608 "\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"+ 15609 "\n\35\f\35\16\35\u0321\13\35\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u0329"+ 15610 "\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"+ 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\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3"+ 15613 "\37\3\37\3\37\3\37\7\37\u0356\n\37\f\37\16\37\u0359\13\37\3\37\3\37\3"+ 15614 " \3 \3 \3 \3 \3 \7 \u0363\n \f \16 \u0366\13 \3 \3 \3!\3!\3!\3!\7!\u036e"+ 15615 "\n!\f!\16!\u0371\13!\3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\""+ 15616 "\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+ 15617 "\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\7\"\u039b\n\"\f\"\16\"\u039e\13"+ 15618 "\"\3\"\3\"\3#\3#\3#\3#\3#\3#\7#\u03a8\n#\f#\16#\u03ab\13#\3#\3#\3$\3$"+ 15619 "\3$\3$\7$\u03b3\n$\f$\16$\u03b6\13$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 15620 "%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+ 15621 "%\3%\3%\3%\3%\3%\7%\u03e0\n%\f%\16%\u03e3\13%\3%\3%\3&\3&\3&\3&\3&\3&"+ 15622 "\7&\u03ed\n&\f&\16&\u03f0\13&\3&\3&\3\'\3\'\3\'\3\'\7\'\u03f8\n\'\f\'"+ 15623 "\16\'\u03fb\13\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+ 15624 "\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3(\3("+ 15625 "\7(\u0425\n(\f(\16(\u0428\13(\3(\3(\3)\3)\3)\3)\3)\3)\7)\u0432\n)\f)\16"+ 15626 ")\u0435\13)\3)\3)\3*\3*\3*\3*\7*\u043d\n*\f*\16*\u0440\13*\3*\3*\3+\3"+ 15627 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3"+ 15628 "+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\7+\u046a\n+\f+\16+\u046d\13+"+ 15629 "\3+\3+\3,\3,\3,\3,\3,\3,\7,\u0477\n,\f,\16,\u047a\13,\3,\3,\3-\3-\3-\3"+ 15630 "-\7-\u0482\n-\f-\16-\u0485\13-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+ 15631 "\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3.\3."+ 15632 "\3.\3.\3.\3.\7.\u04af\n.\f.\16.\u04b2\13.\3.\3.\3/\3/\3/\3/\3/\3/\7/\u04bc"+ 15633 "\n/\f/\16/\u04bf\13/\3/\3/\3\60\3\60\3\60\3\60\7\60\u04c7\n\60\f\60\16"+ 15634 "\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"+ 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\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"+ 15637 "\3\61\7\61\u04f4\n\61\f\61\16\61\u04f7\13\61\3\61\3\61\3\62\3\62\3\62"+ 15638 "\3\62\3\62\3\62\7\62\u0501\n\62\f\62\16\62\u0504\13\62\3\62\3\62\3\63"+ 15639 "\3\63\3\63\3\63\7\63\u050c\n\63\f\63\16\63\u050f\13\63\3\63\3\63\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\3\64\3\64\3\64\3\64\3\64"+ 15642 "\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"+ 15643 "\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"+ 15644 "\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"+ 15645 "\3\66\7\66\u0557\n\66\f\66\16\66\u055a\13\66\3\66\3\66\3\67\3\67\3\67"+ 15646 "\3\67\3\67\3\67\7\67\u0564\n\67\f\67\16\67\u0567\13\67\3\67\3\67\38\3"+ 15647 "8\38\38\38\38\78\u0571\n8\f8\168\u0574\138\38\38\39\39\39\39\39\39\79"+ 15648 "\u057e\n9\f9\169\u0581\139\39\39\3:\3:\3:\3:\3:\3:\7:\u058b\n:\f:\16:"+ 15649 "\u058e\13:\3:\3:\3;\3;\3;\3;\3;\3;\7;\u0598\n;\f;\16;\u059b\13;\3;\3;"+ 15650 "\3<\3<\3<\3<\3<\3<\7<\u05a5\n<\f<\16<\u05a8\13<\3<\3<\3=\3=\3=\3=\3=\3"+ 15651 "=\7=\u05b2\n=\f=\16=\u05b5\13=\3=\3=\3>\3>\3>\3>\3>\3>\7>\u05bf\n>\f>"+ 15652 "\16>\u05c2\13>\3>\3>\3?\3?\3?\3?\3?\3?\7?\u05cc\n?\f?\16?\u05cf\13?\3"+ 15653 "?\3?\3@\3@\3@\3@\3@\3@\7@\u05d9\n@\f@\16@\u05dc\13@\3@\3@\3A\3A\3A\3A"+ 15654 "\3A\3A\7A\u05e6\nA\fA\16A\u05e9\13A\3A\3A\3B\3B\3B\3B\3B\3B\7B\u05f3\n"+ 15655 "B\fB\16B\u05f6\13B\3B\3B\3C\3C\3C\3C\3C\3C\7C\u0600\nC\fC\16C\u0603\13"+ 15656 "C\3C\3C\3D\3D\3D\3D\3D\3D\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\6F\u0617\nF\r"+ 15657 "F\16F\u0618\3G\3G\7G\u061d\nG\fG\16G\u0620\13G\3G\5G\u0623\nG\3G\5G\u0626"+ 15658 "\nG\3G\5G\u0629\nG\3G\6G\u062c\nG\rG\16G\u062d\3G\5G\u0631\nG\3G\5G\u0634"+ 15659 "\nG\3G\5G\u0637\nG\3G\5G\u063a\nG\3G\3G\5G\u063e\nG\5G\u0640\nG\3H\3H"+ 15660 "\7H\u0644\nH\fH\16H\u0647\13H\3H\3H\3I\3I\7I\u064d\nI\fI\16I\u0650\13"+ 15661 "I\3I\5I\u0653\nI\3I\3I\7I\u0657\nI\fI\16I\u065a\13I\3I\5I\u065d\nI\3I"+ 15662 "\3I\7I\u0661\nI\fI\16I\u0664\13I\3I\5I\u0667\nI\3I\7I\u066a\nI\fI\16I"+ 15663 "\u066d\13I\3I\5I\u0670\nI\3I\3I\7I\u0674\nI\fI\16I\u0677\13I\3I\5I\u067a"+ 15664 "\nI\3I\7I\u067d\nI\fI\16I\u0680\13I\3I\5I\u0683\nI\3I\3I\7I\u0687\nI\f"+ 15665 "I\16I\u068a\13I\3I\5I\u068d\nI\3I\3I\7I\u0691\nI\fI\16I\u0694\13I\3I\5"+ 15666 "I\u0697\nI\3I\3I\7I\u069b\nI\fI\16I\u069e\13I\3I\7I\u06a1\nI\fI\16I\u06a4"+ 15667 "\13I\3I\5I\u06a7\nI\3I\3I\7I\u06ab\nI\fI\16I\u06ae\13I\3I\5I\u06b1\nI"+ 15668 "\3I\5I\u06b4\nI\3I\3I\7I\u06b8\nI\fI\16I\u06bb\13I\3I\5I\u06be\nI\3I\3"+ 15669 "I\7I\u06c2\nI\fI\16I\u06c5\13I\3I\5I\u06c8\nI\3I\7I\u06cb\nI\fI\16I\u06ce"+ 15670 "\13I\3I\5I\u06d1\nI\3I\7I\u06d4\nI\fI\16I\u06d7\13I\3I\5I\u06da\nI\3I"+ 15671 "\3I\7I\u06de\nI\fI\16I\u06e1\13I\3I\5I\u06e4\nI\3I\3I\7I\u06e8\nI\fI\16"+ 15672 "I\u06eb\13I\3I\5I\u06ee\nI\3I\7I\u06f1\nI\fI\16I\u06f4\13I\3I\5I\u06f7"+ 15673 "\nI\3I\3I\7I\u06fb\nI\fI\16I\u06fe\13I\3I\5I\u0701\nI\3I\3I\7I\u0705\n"+ 15674 "I\fI\16I\u0708\13I\3I\5I\u070b\nI\5I\u070d\nI\3J\3J\3J\3J\3J\3J\7J\u0715"+ 15675 "\nJ\fJ\16J\u0718\13J\3J\3J\7J\u071c\nJ\fJ\16J\u071f\13J\3J\3J\7J\u0723"+ 15676 "\nJ\fJ\16J\u0726\13J\3J\3J\7J\u072a\nJ\fJ\16J\u072d\13J\3J\3J\5J\u0731"+ 15677 "\nJ\3J\3J\7J\u0735\nJ\fJ\16J\u0738\13J\3J\3J\5J\u073c\nJ\3J\3J\3J\3J\3"+ 15678 "J\7J\u0743\nJ\fJ\16J\u0746\13J\3J\3J\7J\u074a\nJ\fJ\16J\u074d\13J\3J\5"+ 15679 "J\u0750\nJ\3J\3J\7J\u0754\nJ\fJ\16J\u0757\13J\3J\5J\u075a\nJ\5J\u075c"+ 15680 "\nJ\3J\3J\3K\3K\3K\3K\7K\u0764\nK\fK\16K\u0767\13K\3K\3K\3L\3L\6L\u076d"+ 15681 "\nL\rL\16L\u076e\3L\2\2M\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&("+ 15682 "*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084"+ 15683 "\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094\u0096\2\13\5\2\3\3\6"+ 15684 "\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"+ 15685 "\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"+ 15686 "\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"+ 15687 "\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"+ 15688 "\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"+ 15689 " \u0203\3\2\2\2\"\u0210\3\2\2\2$\u021b\3\2\2\2&\u0248\3\2\2\2(\u0255\3"+ 15690 "\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"+ 15691 "\u02d2\3\2\2\2\64\u02df\3\2\2\2\66\u02ea\3\2\2\28\u0317\3\2\2\2:\u0324"+ 15692 "\3\2\2\2<\u032f\3\2\2\2>\u035c\3\2\2\2@\u0369\3\2\2\2B\u0374\3\2\2\2D"+ 15693 "\u03a1\3\2\2\2F\u03ae\3\2\2\2H\u03b9\3\2\2\2J\u03e6\3\2\2\2L\u03f3\3\2"+ 15694 "\2\2N\u03fe\3\2\2\2P\u042b\3\2\2\2R\u0438\3\2\2\2T\u0443\3\2\2\2V\u0470"+ 15695 "\3\2\2\2X\u047d\3\2\2\2Z\u0488\3\2\2\2\\\u04b5\3\2\2\2^\u04c2\3\2\2\2"+ 15696 "`\u04cd\3\2\2\2b\u04fa\3\2\2\2d\u0507\3\2\2\2f\u0512\3\2\2\2h\u054e\3"+ 15697 "\2\2\2j\u0550\3\2\2\2l\u055d\3\2\2\2n\u056a\3\2\2\2p\u0577\3\2\2\2r\u0584"+ 15698 "\3\2\2\2t\u0591\3\2\2\2v\u059e\3\2\2\2x\u05ab\3\2\2\2z\u05b8\3\2\2\2|"+ 15699 "\u05c5\3\2\2\2~\u05d2\3\2\2\2\u0080\u05df\3\2\2\2\u0082\u05ec\3\2\2\2"+ 15700 "\u0084\u05f9\3\2\2\2\u0086\u0606\3\2\2\2\u0088\u060c\3\2\2\2\u008a\u0616"+ 15701 "\3\2\2\2\u008c\u063f\3\2\2\2\u008e\u0641\3\2\2\2\u0090\u070c\3\2\2\2\u0092"+ 15702 "\u070e\3\2\2\2\u0094\u075f\3\2\2\2\u0096\u076c\3\2\2\2\u0098\u00a1\5\4"+ 15703 "\3\2\u0099\u009a\6\2\2\2\u009a\u00a1\7\3\2\2\u009b\u00a1\5\u0094K\2\u009c"+ 15704 "\u00a1\7\5\2\2\u009d\u00a1\7\b\2\2\u009e\u00a1\5\u0096L\2\u009f\u00a1"+ 15705 "\5\u0092J\2\u00a0\u0098\3\2\2\2\u00a0\u0099\3\2\2\2\u00a0\u009b\3\2\2"+ 15706 "\2\u00a0\u009c\3\2\2\2\u00a0\u009d\3\2\2\2\u00a0\u009e\3\2\2\2\u00a0\u009f"+ 15707 "\3\2\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3"+ 15708 "\u00b1\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a5\u00a7\7\3\2\2\u00a6\u00a5\3\2"+ 15709 "\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00ab\3\2\2\2\u00a8\u00aa\7\6\2\2\u00a9"+ 15710 "\u00a8\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00ac\3\2"+ 15711 "\2\2\u00ac\u00ae\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ae\u00b0\5\u0090I\2\u00af"+ 15712 "\u00a6\3\2\2\2\u00b0\u00b3\3\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2"+ 15713 "\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00b1\3\2\2\2\u00b4\u00b5\7\2\2\3\u00b5"+ 15714 "\3\3\2\2\2\u00b6\u00e6\5\f\7\2\u00b7\u00e6\5h\65\2\u00b8\u00e6\5\22\n"+ 15715 "\2\u00b9\u00e6\5\30\r\2\u00ba\u00e6\5\36\20\2\u00bb\u00e6\5$\23\2\u00bc"+ 15716 "\u00e6\5*\26\2\u00bd\u00e6\5\60\31\2\u00be\u00e6\5\66\34\2\u00bf\u00e6"+ 15717 "\5<\37\2\u00c0\u00e6\5B\"\2\u00c1\u00e6\5H%\2\u00c2\u00e6\5N(\2\u00c3"+ 15718 "\u00e6\5T+\2\u00c4\u00e6\5Z.\2\u00c5\u00e6\5f\64\2\u00c6\u00e6\5`\61\2"+ 15719 "\u00c7\u00e6\5\16\b\2\u00c8\u00e6\5\24\13\2\u00c9\u00e6\5\32\16\2\u00ca"+ 15720 "\u00e6\5 \21\2\u00cb\u00e6\5&\24\2\u00cc\u00e6\5,\27\2\u00cd\u00e6\5\62"+ 15721 "\32\2\u00ce\u00e6\58\35\2\u00cf\u00e6\5> \2\u00d0\u00e6\5D#\2\u00d1\u00e6"+ 15722 "\5J&\2\u00d2\u00e6\5P)\2\u00d3\u00e6\5V,\2\u00d4\u00e6\5b\62\2\u00d5\u00e6"+ 15723 "\5\\/\2\u00d6\u00e6\5\20\t\2\u00d7\u00e6\5\26\f\2\u00d8\u00e6\5\34\17"+ 15724 "\2\u00d9\u00e6\5\"\22\2\u00da\u00e6\5(\25\2\u00db\u00e6\5.\30\2\u00dc"+ 15725 "\u00e6\5\64\33\2\u00dd\u00e6\5:\36\2\u00de\u00e6\5@!\2\u00df\u00e6\5F"+ 15726 "$\2\u00e0\u00e6\5L\'\2\u00e1\u00e6\5R*\2\u00e2\u00e6\5X-\2\u00e3\u00e6"+ 15727 "\5d\63\2\u00e4\u00e6\5^\60\2\u00e5\u00b6\3\2\2\2\u00e5\u00b7\3\2\2\2\u00e5"+ 15728 "\u00b8\3\2\2\2\u00e5\u00b9\3\2\2\2\u00e5\u00ba\3\2\2\2\u00e5\u00bb\3\2"+ 15729 "\2\2\u00e5\u00bc\3\2\2\2\u00e5\u00bd\3\2\2\2\u00e5\u00be\3\2\2\2\u00e5"+ 15730 "\u00bf\3\2\2\2\u00e5\u00c0\3\2\2\2\u00e5\u00c1\3\2\2\2\u00e5\u00c2\3\2"+ 15731 "\2\2\u00e5\u00c3\3\2\2\2\u00e5\u00c4\3\2\2\2\u00e5\u00c5\3\2\2\2\u00e5"+ 15732 "\u00c6\3\2\2\2\u00e5\u00c7\3\2\2\2\u00e5\u00c8\3\2\2\2\u00e5\u00c9\3\2"+ 15733 "\2\2\u00e5\u00ca\3\2\2\2\u00e5\u00cb\3\2\2\2\u00e5\u00cc\3\2\2\2\u00e5"+ 15734 "\u00cd\3\2\2\2\u00e5\u00ce\3\2\2\2\u00e5\u00cf\3\2\2\2\u00e5\u00d0\3\2"+ 15735 "\2\2\u00e5\u00d1\3\2\2\2\u00e5\u00d2\3\2\2\2\u00e5\u00d3\3\2\2\2\u00e5"+ 15736 "\u00d4\3\2\2\2\u00e5\u00d5\3\2\2\2\u00e5\u00d6\3\2\2\2\u00e5\u00d7\3\2"+ 15737 "\2\2\u00e5\u00d8\3\2\2\2\u00e5\u00d9\3\2\2\2\u00e5\u00da\3\2\2\2\u00e5"+ 15738 "\u00db\3\2\2\2\u00e5\u00dc\3\2\2\2\u00e5\u00dd\3\2\2\2\u00e5\u00de\3\2"+ 15739 "\2\2\u00e5\u00df\3\2\2\2\u00e5\u00e0\3\2\2\2\u00e5\u00e1\3\2\2\2\u00e5"+ 15740 "\u00e2\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e4\3\2\2\2\u00e6\5\3\2\2\2"+ 15741 "\u00e7\u00e8\7\7\2\2\u00e8\u00ef\7Y\2\2\u00e9\u00ee\5\n\6\2\u00ea\u00ee"+ 15742 "\7\b\2\2\u00eb\u00ee\7\3\2\2\u00ec\u00ee\7\6\2\2\u00ed\u00e9\3\2\2\2\u00ed"+ 15743 "\u00ea\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ec\3\2\2\2\u00ee\u00f1\3\2"+ 15744 "\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0\u00f2\3\2\2\2\u00f1"+ 15745 "\u00ef\3\2\2\2\u00f2\u00f3\79\2\2\u00f3\7\3\2\2\2\u00f4\u00f5\7\7\2\2"+ 15746 "\u00f5\u00f6\7;\2\2\u00f6\u00fa\7Y\2\2\u00f7\u00f9\t\2\2\2\u00f8\u00f7"+ 15747 "\3\2\2\2\u00f9\u00fc\3\2\2\2\u00fa\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb"+ 15748 "\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00fe\79\2\2\u00fe\t\3\2\2\2"+ 15749 "\u00ff\u0103\7Y\2\2\u0100\u0102\t\2\2\2\u0101\u0100\3\2\2\2\u0102\u0105"+ 15750 "\3\2\2\2\u0103\u0101\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105"+ 15751 "\u0103\3\2\2\2\u0106\u010a\7<\2\2\u0107\u0109\t\2\2\2\u0108\u0107\3\2"+ 15752 "\2\2\u0109\u010c\3\2\2\2\u010a\u0108\3\2\2\2\u010a\u010b\3\2\2\2\u010b"+ 15753 "\u0110\3\2\2\2\u010c\u010a\3\2\2\2\u010d\u0111\7[\2\2\u010e\u0111\5\u0096"+ 15754 "L\2\u010f\u0111\7Y\2\2\u0110\u010d\3\2\2\2\u0110\u010e\3\2\2\2\u0110\u010f"+ 15755 "\3\2\2\2\u0111\13\3\2\2\2\u0112\u011d\5\6\4\2\u0113\u011c\5\4\3\2\u0114"+ 15756 "\u0115\6\7\3\2\u0115\u011c\7\3\2\2\u0116\u011c\5\u0094K\2\u0117\u011c"+ 15757 "\7\5\2\2\u0118\u011c\7\b\2\2\u0119\u011c\5\u0096L\2\u011a\u011c\5\u0092"+ 15758 "J\2\u011b\u0113\3\2\2\2\u011b\u0114\3\2\2\2\u011b\u0116\3\2\2\2\u011b"+ 15759 "\u0117\3\2\2\2\u011b\u0118\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011a\3\2"+ 15760 "\2\2\u011c\u011f\3\2\2\2\u011d\u011b\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+ 15761 "\u0120\3\2\2\2\u011f\u011d\3\2\2\2\u0120\u0121\5\b\5\2\u0121\u0133\3\2"+ 15762 "\2\2\u0122\u012d\5\6\4\2\u0123\u012c\5\4\3\2\u0124\u0125\6\7\4\2\u0125"+ 15763 "\u012c\7\3\2\2\u0126\u012c\5\u0094K\2\u0127\u012c\7\5\2\2\u0128\u012c"+ 15764 "\7\b\2\2\u0129\u012c\5\u0096L\2\u012a\u012c\5\u0092J\2\u012b\u0123\3\2"+ 15765 "\2\2\u012b\u0124\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012b"+ 15766 "\u0128\3\2\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f\3\2"+ 15767 "\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u0130\3\2\2\2\u012f"+ 15768 "\u012d\3\2\2\2\u0130\u0131\b\7\1\2\u0131\u0133\3\2\2\2\u0132\u0112\3\2"+ 15769 "\2\2\u0132\u0122\3\2\2\2\u0133\r\3\2\2\2\u0134\u0135\7\7\2\2\u0135\u013c"+ 15770 "\7=\2\2\u0136\u013b\5\n\6\2\u0137\u013b\7\b\2\2\u0138\u013b\7\3\2\2\u0139"+ 15771 "\u013b\7\6\2\2\u013a\u0136\3\2\2\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2"+ 15772 "\2\2\u013a\u0139\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c"+ 15773 "\u013d\3\2\2\2\u013d\u013f\3\2\2\2\u013e\u013c\3\2\2\2\u013f\u0140\79"+ 15774 "\2\2\u0140\17\3\2\2\2\u0141\u0142\7\7\2\2\u0142\u0143\7;\2\2\u0143\u0147"+ 15775 "\7=\2\2\u0144\u0146\t\2\2\2\u0145\u0144\3\2\2\2\u0146\u0149\3\2\2\2\u0147"+ 15776 "\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148\u014a\3\2\2\2\u0149\u0147\3\2"+ 15777 "\2\2\u014a\u014b\79\2\2\u014b\21\3\2\2\2\u014c\u0174\5\16\b\2\u014d\u0173"+ 15778 "\5\f\7\2\u014e\u0173\5j\66\2\u014f\u0173\5\30\r\2\u0150\u0173\5\36\20"+ 15779 "\2\u0151\u0173\5$\23\2\u0152\u0173\5*\26\2\u0153\u0173\5\60\31\2\u0154"+ 15780 "\u0173\5\66\34\2\u0155\u0173\5<\37\2\u0156\u0173\5B\"\2\u0157\u0173\5"+ 15781 "H%\2\u0158\u0173\5N(\2\u0159\u0173\5T+\2\u015a\u0173\5Z.\2\u015b\u0173"+ 15782 "\5f\64\2\u015c\u0173\5`\61\2\u015d\u0173\5\24\13\2\u015e\u0173\5\32\16"+ 15783 "\2\u015f\u0173\5 \21\2\u0160\u0173\5&\24\2\u0161\u0173\5,\27\2\u0162\u0173"+ 15784 "\5\62\32\2\u0163\u0173\58\35\2\u0164\u0173\5> \2\u0165\u0173\5D#\2\u0166"+ 15785 "\u0173\5J&\2\u0167\u0173\5P)\2\u0168\u0173\5V,\2\u0169\u0173\5b\62\2\u016a"+ 15786 "\u0173\5\\/\2\u016b\u016c\6\n\5\2\u016c\u0173\7\3\2\2\u016d\u0173\5\u0094"+ 15787 "K\2\u016e\u0173\7\5\2\2\u016f\u0173\7\b\2\2\u0170\u0173\5\u0096L\2\u0171"+ 15788 "\u0173\5\u0092J\2\u0172\u014d\3\2\2\2\u0172\u014e\3\2\2\2\u0172\u014f"+ 15789 "\3\2\2\2\u0172\u0150\3\2\2\2\u0172\u0151\3\2\2\2\u0172\u0152\3\2\2\2\u0172"+ 15790 "\u0153\3\2\2\2\u0172\u0154\3\2\2\2\u0172\u0155\3\2\2\2\u0172\u0156\3\2"+ 15791 "\2\2\u0172\u0157\3\2\2\2\u0172\u0158\3\2\2\2\u0172\u0159\3\2\2\2\u0172"+ 15792 "\u015a\3\2\2\2\u0172\u015b\3\2\2\2\u0172\u015c\3\2\2\2\u0172\u015d\3\2"+ 15793 "\2\2\u0172\u015e\3\2\2\2\u0172\u015f\3\2\2\2\u0172\u0160\3\2\2\2\u0172"+ 15794 "\u0161\3\2\2\2\u0172\u0162\3\2\2\2\u0172\u0163\3\2\2\2\u0172\u0164\3\2"+ 15795 "\2\2\u0172\u0165\3\2\2\2\u0172\u0166\3\2\2\2\u0172\u0167\3\2\2\2\u0172"+ 15796 "\u0168\3\2\2\2\u0172\u0169\3\2\2\2\u0172\u016a\3\2\2\2\u0172\u016b\3\2"+ 15797 "\2\2\u0172\u016d\3\2\2\2\u0172\u016e\3\2\2\2\u0172\u016f\3\2\2\2\u0172"+ 15798 "\u0170\3\2\2\2\u0172\u0171\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0172\3\2"+ 15799 "\2\2\u0174\u0175\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2\u0177"+ 15800 "\u0178\5\20\t\2\u0178\23\3\2\2\2\u0179\u017a\7\7\2\2\u017a\u0181\7>\2"+ 15801 "\2\u017b\u0180\5\n\6\2\u017c\u0180\7\b\2\2\u017d\u0180\7\3\2\2\u017e\u0180"+ 15802 "\7\6\2\2\u017f\u017b\3\2\2\2\u017f\u017c\3\2\2\2\u017f\u017d\3\2\2\2\u017f"+ 15803 "\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0181\u0182\3\2"+ 15804 "\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184\u0185\79\2\2\u0185"+ 15805 "\25\3\2\2\2\u0186\u0187\7\7\2\2\u0187\u0188\7;\2\2\u0188\u018c\7>\2\2"+ 15806 "\u0189\u018b\t\2\2\2\u018a\u0189\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a"+ 15807 "\3\2\2\2\u018c\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f"+ 15808 "\u0190\79\2\2\u0190\27\3\2\2\2\u0191\u01b9\5\24\13\2\u0192\u01b8\5\f\7"+ 15809 "\2\u0193\u01b8\5j\66\2\u0194\u01b8\5\22\n\2\u0195\u01b8\5\36\20\2\u0196"+ 15810 "\u01b8\5$\23\2\u0197\u01b8\5*\26\2\u0198\u01b8\5\60\31\2\u0199\u01b8\5"+ 15811 "\66\34\2\u019a\u01b8\5<\37\2\u019b\u01b8\5B\"\2\u019c\u01b8\5H%\2\u019d"+ 15812 "\u01b8\5N(\2\u019e\u01b8\5T+\2\u019f\u01b8\5Z.\2\u01a0\u01b8\5f\64\2\u01a1"+ 15813 "\u01b8\5`\61\2\u01a2\u01b8\5\16\b\2\u01a3\u01b8\5\32\16\2\u01a4\u01b8"+ 15814 "\5 \21\2\u01a5\u01b8\5&\24\2\u01a6\u01b8\5,\27\2\u01a7\u01b8\5\62\32\2"+ 15815 "\u01a8\u01b8\58\35\2\u01a9\u01b8\5> \2\u01aa\u01b8\5D#\2\u01ab\u01b8\5"+ 15816 "J&\2\u01ac\u01b8\5P)\2\u01ad\u01b8\5V,\2\u01ae\u01b8\5b\62\2\u01af\u01b8"+ 15817 "\5\\/\2\u01b0\u01b1\6\r\6\2\u01b1\u01b8\7\3\2\2\u01b2\u01b8\5\u0094K\2"+ 15818 "\u01b3\u01b8\7\5\2\2\u01b4\u01b8\7\b\2\2\u01b5\u01b8\5\u0096L\2\u01b6"+ 15819 "\u01b8\5\u0092J\2\u01b7\u0192\3\2\2\2\u01b7\u0193\3\2\2\2\u01b7\u0194"+ 15820 "\3\2\2\2\u01b7\u0195\3\2\2\2\u01b7\u0196\3\2\2\2\u01b7\u0197\3\2\2\2\u01b7"+ 15821 "\u0198\3\2\2\2\u01b7\u0199\3\2\2\2\u01b7\u019a\3\2\2\2\u01b7\u019b\3\2"+ 15822 "\2\2\u01b7\u019c\3\2\2\2\u01b7\u019d\3\2\2\2\u01b7\u019e\3\2\2\2\u01b7"+ 15823 "\u019f\3\2\2\2\u01b7\u01a0\3\2\2\2\u01b7\u01a1\3\2\2\2\u01b7\u01a2\3\2"+ 15824 "\2\2\u01b7\u01a3\3\2\2\2\u01b7\u01a4\3\2\2\2\u01b7\u01a5\3\2\2\2\u01b7"+ 15825 "\u01a6\3\2\2\2\u01b7\u01a7\3\2\2\2\u01b7\u01a8\3\2\2\2\u01b7\u01a9\3\2"+ 15826 "\2\2\u01b7\u01aa\3\2\2\2\u01b7\u01ab\3\2\2\2\u01b7\u01ac\3\2\2\2\u01b7"+ 15827 "\u01ad\3\2\2\2\u01b7\u01ae\3\2\2\2\u01b7\u01af\3\2\2\2\u01b7\u01b0\3\2"+ 15828 "\2\2\u01b7\u01b2\3\2\2\2\u01b7\u01b3\3\2\2\2\u01b7\u01b4\3\2\2\2\u01b7"+ 15829 "\u01b5\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2"+ 15830 "\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc"+ 15831 "\u01bd\5\26\f\2\u01bd\31\3\2\2\2\u01be\u01bf\7\7\2\2\u01bf\u01c6\7?\2"+ 15832 "\2\u01c0\u01c5\5\n\6\2\u01c1\u01c5\7\b\2\2\u01c2\u01c5\7\3\2\2\u01c3\u01c5"+ 15833 "\7\6\2\2\u01c4\u01c0\3\2\2\2\u01c4\u01c1\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c4"+ 15834 "\u01c3\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2"+ 15835 "\2\2\u01c7\u01c9\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01ca\79\2\2\u01ca"+ 15836 "\33\3\2\2\2\u01cb\u01cc\7\7\2\2\u01cc\u01cd\7;\2\2\u01cd\u01d1\7?\2\2"+ 15837 "\u01ce\u01d0\t\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf"+ 15838 "\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2\u01d4\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4"+ 15839 "\u01d5\79\2\2\u01d5\35\3\2\2\2\u01d6\u01fe\5\32\16\2\u01d7\u01fd\5\f\7"+ 15840 "\2\u01d8\u01fd\5j\66\2\u01d9\u01fd\5\22\n\2\u01da\u01fd\5\30\r\2\u01db"+ 15841 "\u01fd\5$\23\2\u01dc\u01fd\5*\26\2\u01dd\u01fd\5\60\31\2\u01de\u01fd\5"+ 15842 "\66\34\2\u01df\u01fd\5<\37\2\u01e0\u01fd\5B\"\2\u01e1\u01fd\5H%\2\u01e2"+ 15843 "\u01fd\5N(\2\u01e3\u01fd\5T+\2\u01e4\u01fd\5Z.\2\u01e5\u01fd\5f\64\2\u01e6"+ 15844 "\u01fd\5`\61\2\u01e7\u01fd\5\16\b\2\u01e8\u01fd\5\24\13\2\u01e9\u01fd"+ 15845 "\5 \21\2\u01ea\u01fd\5&\24\2\u01eb\u01fd\5,\27\2\u01ec\u01fd\5\62\32\2"+ 15846 "\u01ed\u01fd\58\35\2\u01ee\u01fd\5> \2\u01ef\u01fd\5D#\2\u01f0\u01fd\5"+ 15847 "J&\2\u01f1\u01fd\5P)\2\u01f2\u01fd\5V,\2\u01f3\u01fd\5b\62\2\u01f4\u01fd"+ 15848 "\5\\/\2\u01f5\u01f6\6\20\7\2\u01f6\u01fd\7\3\2\2\u01f7\u01fd\5\u0094K"+ 15849 "\2\u01f8\u01fd\7\5\2\2\u01f9\u01fd\7\b\2\2\u01fa\u01fd\5\u0096L\2\u01fb"+ 15850 "\u01fd\5\u0092J\2\u01fc\u01d7\3\2\2\2\u01fc\u01d8\3\2\2\2\u01fc\u01d9"+ 15851 "\3\2\2\2\u01fc\u01da\3\2\2\2\u01fc\u01db\3\2\2\2\u01fc\u01dc\3\2\2\2\u01fc"+ 15852 "\u01dd\3\2\2\2\u01fc\u01de\3\2\2\2\u01fc\u01df\3\2\2\2\u01fc\u01e0\3\2"+ 15853 "\2\2\u01fc\u01e1\3\2\2\2\u01fc\u01e2\3\2\2\2\u01fc\u01e3\3\2\2\2\u01fc"+ 15854 "\u01e4\3\2\2\2\u01fc\u01e5\3\2\2\2\u01fc\u01e6\3\2\2\2\u01fc\u01e7\3\2"+ 15855 "\2\2\u01fc\u01e8\3\2\2\2\u01fc\u01e9\3\2\2\2\u01fc\u01ea\3\2\2\2\u01fc"+ 15856 "\u01eb\3\2\2\2\u01fc\u01ec\3\2\2\2\u01fc\u01ed\3\2\2\2\u01fc\u01ee\3\2"+ 15857 "\2\2\u01fc\u01ef\3\2\2\2\u01fc\u01f0\3\2\2\2\u01fc\u01f1\3\2\2\2\u01fc"+ 15858 "\u01f2\3\2\2\2\u01fc\u01f3\3\2\2\2\u01fc\u01f4\3\2\2\2\u01fc\u01f5\3\2"+ 15859 "\2\2\u01fc\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc"+ 15860 "\u01fa\3\2\2\2\u01fc\u01fb\3\2\2\2\u01fd\u0200\3\2\2\2\u01fe\u01fc\3\2"+ 15861 "\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0201\3\2\2\2\u0200\u01fe\3\2\2\2\u0201"+ 15862 "\u0202\5\34\17\2\u0202\37\3\2\2\2\u0203\u0204\7\7\2\2\u0204\u020b\7@\2"+ 15863 "\2\u0205\u020a\5\n\6\2\u0206\u020a\7\b\2\2\u0207\u020a\7\3\2\2\u0208\u020a"+ 15864 "\7\6\2\2\u0209\u0205\3\2\2\2\u0209\u0206\3\2\2\2\u0209\u0207\3\2\2\2\u0209"+ 15865 "\u0208\3\2\2\2\u020a\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2"+ 15866 "\2\2\u020c\u020e\3\2\2\2\u020d\u020b\3\2\2\2\u020e\u020f\79\2\2\u020f"+ 15867 "!\3\2\2\2\u0210\u0211\7\7\2\2\u0211\u0212\7;\2\2\u0212\u0216\7@\2\2\u0213"+ 15868 "\u0215\t\2\2\2\u0214\u0213\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2"+ 15869 "\2\2\u0216\u0217\3\2\2\2\u0217\u0219\3\2\2\2\u0218\u0216\3\2\2\2\u0219"+ 15870 "\u021a\79\2\2\u021a#\3\2\2\2\u021b\u0243\5 \21\2\u021c\u0242\5\f\7\2\u021d"+ 15871 "\u0242\5j\66\2\u021e\u0242\5\22\n\2\u021f\u0242\5\30\r\2\u0220\u0242\5"+ 15872 "\36\20\2\u0221\u0242\5*\26\2\u0222\u0242\5\60\31\2\u0223\u0242\5\66\34"+ 15873 "\2\u0224\u0242\5<\37\2\u0225\u0242\5B\"\2\u0226\u0242\5H%\2\u0227\u0242"+ 15874 "\5N(\2\u0228\u0242\5T+\2\u0229\u0242\5Z.\2\u022a\u0242\5f\64\2\u022b\u0242"+ 15875 "\5`\61\2\u022c\u0242\5\16\b\2\u022d\u0242\5\24\13\2\u022e\u0242\5 \21"+ 15876 "\2\u022f\u0242\5&\24\2\u0230\u0242\5,\27\2\u0231\u0242\5\62\32\2\u0232"+ 15877 "\u0242\58\35\2\u0233\u0242\5> \2\u0234\u0242\5D#\2\u0235\u0242\5J&\2\u0236"+ 15878 "\u0242\5P)\2\u0237\u0242\5V,\2\u0238\u0242\5b\62\2\u0239\u0242\5\\/\2"+ 15879 "\u023a\u023b\6\23\b\2\u023b\u0242\7\3\2\2\u023c\u0242\5\u0094K\2\u023d"+ 15880 "\u0242\7\5\2\2\u023e\u0242\7\b\2\2\u023f\u0242\5\u0096L\2\u0240\u0242"+ 15881 "\5\u0092J\2\u0241\u021c\3\2\2\2\u0241\u021d\3\2\2\2\u0241\u021e\3\2\2"+ 15882 "\2\u0241\u021f\3\2\2\2\u0241\u0220\3\2\2\2\u0241\u0221\3\2\2\2\u0241\u0222"+ 15883 "\3\2\2\2\u0241\u0223\3\2\2\2\u0241\u0224\3\2\2\2\u0241\u0225\3\2\2\2\u0241"+ 15884 "\u0226\3\2\2\2\u0241\u0227\3\2\2\2\u0241\u0228\3\2\2\2\u0241\u0229\3\2"+ 15885 "\2\2\u0241\u022a\3\2\2\2\u0241\u022b\3\2\2\2\u0241\u022c\3\2\2\2\u0241"+ 15886 "\u022d\3\2\2\2\u0241\u022e\3\2\2\2\u0241\u022f\3\2\2\2\u0241\u0230\3\2"+ 15887 "\2\2\u0241\u0231\3\2\2\2\u0241\u0232\3\2\2\2\u0241\u0233\3\2\2\2\u0241"+ 15888 "\u0234\3\2\2\2\u0241\u0235\3\2\2\2\u0241\u0236\3\2\2\2\u0241\u0237\3\2"+ 15889 "\2\2\u0241\u0238\3\2\2\2\u0241\u0239\3\2\2\2\u0241\u023a\3\2\2\2\u0241"+ 15890 "\u023c\3\2\2\2\u0241\u023d\3\2\2\2\u0241\u023e\3\2\2\2\u0241\u023f\3\2"+ 15891 "\2\2\u0241\u0240\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243"+ 15892 "\u0244\3\2\2\2\u0244\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\5\""+ 15893 "\22\2\u0247%\3\2\2\2\u0248\u0249\7\7\2\2\u0249\u0250\7A\2\2\u024a\u024f"+ 15894 "\5\n\6\2\u024b\u024f\7\b\2\2\u024c\u024f\7\3\2\2\u024d\u024f\7\6\2\2\u024e"+ 15895 "\u024a\3\2\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2\u024e\u024d\3\2"+ 15896 "\2\2\u024f\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2\2\u0251"+ 15897 "\u0253\3\2\2\2\u0252\u0250\3\2\2\2\u0253\u0254\79\2\2\u0254\'\3\2\2\2"+ 15898 "\u0255\u0256\7\7\2\2\u0256\u0257\7;\2\2\u0257\u025b\7A\2\2\u0258\u025a"+ 15899 "\t\2\2\2\u0259\u0258\3\2\2\2\u025a\u025d\3\2\2\2\u025b\u0259\3\2\2\2\u025b"+ 15900 "\u025c\3\2\2\2\u025c\u025e\3\2\2\2\u025d\u025b\3\2\2\2\u025e\u025f\79"+ 15901 "\2\2\u025f)\3\2\2\2\u0260\u0288\5&\24\2\u0261\u0287\5\f\7\2\u0262\u0287"+ 15902 "\5j\66\2\u0263\u0287\5\22\n\2\u0264\u0287\5\30\r\2\u0265\u0287\5\36\20"+ 15903 "\2\u0266\u0287\5$\23\2\u0267\u0287\5\60\31\2\u0268\u0287\5\66\34\2\u0269"+ 15904 "\u0287\5<\37\2\u026a\u0287\5B\"\2\u026b\u0287\5H%\2\u026c\u0287\5N(\2"+ 15905 "\u026d\u0287\5T+\2\u026e\u0287\5Z.\2\u026f\u0287\5f\64\2\u0270\u0287\5"+ 15906 "`\61\2\u0271\u0287\5\16\b\2\u0272\u0287\5\24\13\2\u0273\u0287\5\32\16"+ 15907 "\2\u0274\u0287\5 \21\2\u0275\u0287\5,\27\2\u0276\u0287\5\62\32\2\u0277"+ 15908 "\u0287\58\35\2\u0278\u0287\5> \2\u0279\u0287\5D#\2\u027a\u0287\5J&\2\u027b"+ 15909 "\u0287\5P)\2\u027c\u0287\5V,\2\u027d\u0287\5b\62\2\u027e\u0287\5\\/\2"+ 15910 "\u027f\u0280\6\26\t\2\u0280\u0287\7\3\2\2\u0281\u0287\5\u0094K\2\u0282"+ 15911 "\u0287\7\5\2\2\u0283\u0287\7\b\2\2\u0284\u0287\5\u0096L\2\u0285\u0287"+ 15912 "\5\u0092J\2\u0286\u0261\3\2\2\2\u0286\u0262\3\2\2\2\u0286\u0263\3\2\2"+ 15913 "\2\u0286\u0264\3\2\2\2\u0286\u0265\3\2\2\2\u0286\u0266\3\2\2\2\u0286\u0267"+ 15914 "\3\2\2\2\u0286\u0268\3\2\2\2\u0286\u0269\3\2\2\2\u0286\u026a\3\2\2\2\u0286"+ 15915 "\u026b\3\2\2\2\u0286\u026c\3\2\2\2\u0286\u026d\3\2\2\2\u0286\u026e\3\2"+ 15916 "\2\2\u0286\u026f\3\2\2\2\u0286\u0270\3\2\2\2\u0286\u0271\3\2\2\2\u0286"+ 15917 "\u0272\3\2\2\2\u0286\u0273\3\2\2\2\u0286\u0274\3\2\2\2\u0286\u0275\3\2"+ 15918 "\2\2\u0286\u0276\3\2\2\2\u0286\u0277\3\2\2\2\u0286\u0278\3\2\2\2\u0286"+ 15919 "\u0279\3\2\2\2\u0286\u027a\3\2\2\2\u0286\u027b\3\2\2\2\u0286\u027c\3\2"+ 15920 "\2\2\u0286\u027d\3\2\2\2\u0286\u027e\3\2\2\2\u0286\u027f\3\2\2\2\u0286"+ 15921 "\u0281\3\2\2\2\u0286\u0282\3\2\2\2\u0286\u0283\3\2\2\2\u0286\u0284\3\2"+ 15922 "\2\2\u0286\u0285\3\2\2\2\u0287\u028a\3\2\2\2\u0288\u0286\3\2\2\2\u0288"+ 15923 "\u0289\3\2\2\2\u0289\u028b\3\2\2\2\u028a\u0288\3\2\2\2\u028b\u028c\5("+ 15924 "\25\2\u028c+\3\2\2\2\u028d\u028e\7\7\2\2\u028e\u0295\7B\2\2\u028f\u0294"+ 15925 "\5\n\6\2\u0290\u0294\7\b\2\2\u0291\u0294\7\3\2\2\u0292\u0294\7\6\2\2\u0293"+ 15926 "\u028f\3\2\2\2\u0293\u0290\3\2\2\2\u0293\u0291\3\2\2\2\u0293\u0292\3\2"+ 15927 "\2\2\u0294\u0297\3\2\2\2\u0295\u0293\3\2\2\2\u0295\u0296\3\2\2\2\u0296"+ 15928 "\u0298\3\2\2\2\u0297\u0295\3\2\2\2\u0298\u0299\79\2\2\u0299-\3\2\2\2\u029a"+ 15929 "\u029b\7\7\2\2\u029b\u029c\7;\2\2\u029c\u02a0\7B\2\2\u029d\u029f\t\2\2"+ 15930 "\2\u029e\u029d\3\2\2\2\u029f\u02a2\3\2\2\2\u02a0\u029e\3\2\2\2\u02a0\u02a1"+ 15931 "\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a3\u02a4\79\2\2\u02a4"+ 15932 "/\3\2\2\2\u02a5\u02cd\5,\27\2\u02a6\u02cc\5\f\7\2\u02a7\u02cc\5j\66\2"+ 15933 "\u02a8\u02cc\5\22\n\2\u02a9\u02cc\5\30\r\2\u02aa\u02cc\5\36\20\2\u02ab"+ 15934 "\u02cc\5$\23\2\u02ac\u02cc\5*\26\2\u02ad\u02cc\5\66\34\2\u02ae\u02cc\5"+ 15935 "<\37\2\u02af\u02cc\5B\"\2\u02b0\u02cc\5H%\2\u02b1\u02cc\5N(\2\u02b2\u02cc"+ 15936 "\5T+\2\u02b3\u02cc\5Z.\2\u02b4\u02cc\5f\64\2\u02b5\u02cc\5`\61\2\u02b6"+ 15937 "\u02cc\5\16\b\2\u02b7\u02cc\5\24\13\2\u02b8\u02cc\5\32\16\2\u02b9\u02cc"+ 15938 "\5 \21\2\u02ba\u02cc\5&\24\2\u02bb\u02cc\5\62\32\2\u02bc\u02cc\58\35\2"+ 15939 "\u02bd\u02cc\5> \2\u02be\u02cc\5D#\2\u02bf\u02cc\5J&\2\u02c0\u02cc\5P"+ 15940 ")\2\u02c1\u02cc\5V,\2\u02c2\u02cc\5b\62\2\u02c3\u02cc\5\\/\2\u02c4\u02c5"+ 15941 "\6\31\n\2\u02c5\u02cc\7\3\2\2\u02c6\u02cc\5\u0094K\2\u02c7\u02cc\7\5\2"+ 15942 "\2\u02c8\u02cc\7\b\2\2\u02c9\u02cc\5\u0096L\2\u02ca\u02cc\5\u0092J\2\u02cb"+ 15943 "\u02a6\3\2\2\2\u02cb\u02a7\3\2\2\2\u02cb\u02a8\3\2\2\2\u02cb\u02a9\3\2"+ 15944 "\2\2\u02cb\u02aa\3\2\2\2\u02cb\u02ab\3\2\2\2\u02cb\u02ac\3\2\2\2\u02cb"+ 15945 "\u02ad\3\2\2\2\u02cb\u02ae\3\2\2\2\u02cb\u02af\3\2\2\2\u02cb\u02b0\3\2"+ 15946 "\2\2\u02cb\u02b1\3\2\2\2\u02cb\u02b2\3\2\2\2\u02cb\u02b3\3\2\2\2\u02cb"+ 15947 "\u02b4\3\2\2\2\u02cb\u02b5\3\2\2\2\u02cb\u02b6\3\2\2\2\u02cb\u02b7\3\2"+ 15948 "\2\2\u02cb\u02b8\3\2\2\2\u02cb\u02b9\3\2\2\2\u02cb\u02ba\3\2\2\2\u02cb"+ 15949 "\u02bb\3\2\2\2\u02cb\u02bc\3\2\2\2\u02cb\u02bd\3\2\2\2\u02cb\u02be\3\2"+ 15950 "\2\2\u02cb\u02bf\3\2\2\2\u02cb\u02c0\3\2\2\2\u02cb\u02c1\3\2\2\2\u02cb"+ 15951 "\u02c2\3\2\2\2\u02cb\u02c3\3\2\2\2\u02cb\u02c4\3\2\2\2\u02cb\u02c6\3\2"+ 15952 "\2\2\u02cb\u02c7\3\2\2\2\u02cb\u02c8\3\2\2\2\u02cb\u02c9\3\2\2\2\u02cb"+ 15953 "\u02ca\3\2\2\2\u02cc\u02cf\3\2\2\2\u02cd\u02cb\3\2\2\2\u02cd\u02ce\3\2"+ 15954 "\2\2\u02ce\u02d0\3\2\2\2\u02cf\u02cd\3\2\2\2\u02d0\u02d1\5.\30\2\u02d1"+ 15955 "\61\3\2\2\2\u02d2\u02d3\7\7\2\2\u02d3\u02da\7C\2\2\u02d4\u02d9\5\n\6\2"+ 15956 "\u02d5\u02d9\7\b\2\2\u02d6\u02d9\7\3\2\2\u02d7\u02d9\7\6\2\2\u02d8\u02d4"+ 15957 "\3\2\2\2\u02d8\u02d5\3\2\2\2\u02d8\u02d6\3\2\2\2\u02d8\u02d7\3\2\2\2\u02d9"+ 15958 "\u02dc\3\2\2\2\u02da\u02d8\3\2\2\2\u02da\u02db\3\2\2\2\u02db\u02dd\3\2"+ 15959 "\2\2\u02dc\u02da\3\2\2\2\u02dd\u02de\79\2\2\u02de\63\3\2\2\2\u02df\u02e0"+ 15960 "\7\7\2\2\u02e0\u02e1\7;\2\2\u02e1\u02e5\7C\2\2\u02e2\u02e4\t\2\2\2\u02e3"+ 15961 "\u02e2\3\2\2\2\u02e4\u02e7\3\2\2\2\u02e5\u02e3\3\2\2\2\u02e5\u02e6\3\2"+ 15962 "\2\2\u02e6\u02e8\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e8\u02e9\79\2\2\u02e9"+ 15963 "\65\3\2\2\2\u02ea\u0312\5\62\32\2\u02eb\u0311\5\f\7\2\u02ec\u0311\5j\66"+ 15964 "\2\u02ed\u0311\5\22\n\2\u02ee\u0311\5\30\r\2\u02ef\u0311\5\36\20\2\u02f0"+ 15965 "\u0311\5$\23\2\u02f1\u0311\5*\26\2\u02f2\u0311\5\60\31\2\u02f3\u0311\5"+ 15966 "<\37\2\u02f4\u0311\5B\"\2\u02f5\u0311\5H%\2\u02f6\u0311\5N(\2\u02f7\u0311"+ 15967 "\5T+\2\u02f8\u0311\5Z.\2\u02f9\u0311\5f\64\2\u02fa\u0311\5`\61\2\u02fb"+ 15968 "\u0311\5\16\b\2\u02fc\u0311\5\24\13\2\u02fd\u0311\5\32\16\2\u02fe\u0311"+ 15969 "\5 \21\2\u02ff\u0311\5&\24\2\u0300\u0311\5,\27\2\u0301\u0311\58\35\2\u0302"+ 15970 "\u0311\5> \2\u0303\u0311\5D#\2\u0304\u0311\5J&\2\u0305\u0311\5P)\2\u0306"+ 15971 "\u0311\5V,\2\u0307\u0311\5b\62\2\u0308\u0311\5\\/\2\u0309\u030a\6\34\13"+ 15972 "\2\u030a\u0311\7\3\2\2\u030b\u0311\5\u0094K\2\u030c\u0311\7\5\2\2\u030d"+ 15973 "\u0311\7\b\2\2\u030e\u0311\5\u0096L\2\u030f\u0311\5\u0092J\2\u0310\u02eb"+ 15974 "\3\2\2\2\u0310\u02ec\3\2\2\2\u0310\u02ed\3\2\2\2\u0310\u02ee\3\2\2\2\u0310"+ 15975 "\u02ef\3\2\2\2\u0310\u02f0\3\2\2\2\u0310\u02f1\3\2\2\2\u0310\u02f2\3\2"+ 15976 "\2\2\u0310\u02f3\3\2\2\2\u0310\u02f4\3\2\2\2\u0310\u02f5\3\2\2\2\u0310"+ 15977 "\u02f6\3\2\2\2\u0310\u02f7\3\2\2\2\u0310\u02f8\3\2\2\2\u0310\u02f9\3\2"+ 15978 "\2\2\u0310\u02fa\3\2\2\2\u0310\u02fb\3\2\2\2\u0310\u02fc\3\2\2\2\u0310"+ 15979 "\u02fd\3\2\2\2\u0310\u02fe\3\2\2\2\u0310\u02ff\3\2\2\2\u0310\u0300\3\2"+ 15980 "\2\2\u0310\u0301\3\2\2\2\u0310\u0302\3\2\2\2\u0310\u0303\3\2\2\2\u0310"+ 15981 "\u0304\3\2\2\2\u0310\u0305\3\2\2\2\u0310\u0306\3\2\2\2\u0310\u0307\3\2"+ 15982 "\2\2\u0310\u0308\3\2\2\2\u0310\u0309\3\2\2\2\u0310\u030b\3\2\2\2\u0310"+ 15983 "\u030c\3\2\2\2\u0310\u030d\3\2\2\2\u0310\u030e\3\2\2\2\u0310\u030f\3\2"+ 15984 "\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313"+ 15985 "\u0315\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u0316\5\64\33\2\u0316\67\3\2"+ 15986 "\2\2\u0317\u0318\7\7\2\2\u0318\u031f\7D\2\2\u0319\u031e\5\n\6\2\u031a"+ 15987 "\u031e\7\b\2\2\u031b\u031e\7\3\2\2\u031c\u031e\7\6\2\2\u031d\u0319\3\2"+ 15988 "\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031c\3\2\2\2\u031e"+ 15989 "\u0321\3\2\2\2\u031f\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2"+ 15990 "\2\2\u0321\u031f\3\2\2\2\u0322\u0323\79\2\2\u03239\3\2\2\2\u0324\u0325"+ 15991 "\7\7\2\2\u0325\u0326\7;\2\2\u0326\u032a\7D\2\2\u0327\u0329\t\2\2\2\u0328"+ 15992 "\u0327\3\2\2\2\u0329\u032c\3\2\2\2\u032a\u0328\3\2\2\2\u032a\u032b\3\2"+ 15993 "\2\2\u032b\u032d\3\2\2\2\u032c\u032a\3\2\2\2\u032d\u032e\79\2\2\u032e"+ 15994 ";\3\2\2\2\u032f\u0357\58\35\2\u0330\u0356\5\f\7\2\u0331\u0356\5j\66\2"+ 15995 "\u0332\u0356\5\22\n\2\u0333\u0356\5\30\r\2\u0334\u0356\5\36\20\2\u0335"+ 15996 "\u0356\5$\23\2\u0336\u0356\5*\26\2\u0337\u0356\5\60\31\2\u0338\u0356\5"+ 15997 "\66\34\2\u0339\u0356\5B\"\2\u033a\u0356\5H%\2\u033b\u0356\5N(\2\u033c"+ 15998 "\u0356\5T+\2\u033d\u0356\5Z.\2\u033e\u0356\5f\64\2\u033f\u0356\5`\61\2"+ 15999 "\u0340\u0356\5\16\b\2\u0341\u0356\5\24\13\2\u0342\u0356\5\32\16\2\u0343"+ 16000 "\u0356\5 \21\2\u0344\u0356\5&\24\2\u0345\u0356\5,\27\2\u0346\u0356\5\62"+ 16001 "\32\2\u0347\u0356\5> \2\u0348\u0356\5D#\2\u0349\u0356\5J&\2\u034a\u0356"+ 16002 "\5P)\2\u034b\u0356\5V,\2\u034c\u0356\5b\62\2\u034d\u0356\5\\/\2\u034e"+ 16003 "\u034f\6\37\f\2\u034f\u0356\7\3\2\2\u0350\u0356\5\u0094K\2\u0351\u0356"+ 16004 "\7\5\2\2\u0352\u0356\7\b\2\2\u0353\u0356\5\u0096L\2\u0354\u0356\5\u0092"+ 16005 "J\2\u0355\u0330\3\2\2\2\u0355\u0331\3\2\2\2\u0355\u0332\3\2\2\2\u0355"+ 16006 "\u0333\3\2\2\2\u0355\u0334\3\2\2\2\u0355\u0335\3\2\2\2\u0355\u0336\3\2"+ 16007 "\2\2\u0355\u0337\3\2\2\2\u0355\u0338\3\2\2\2\u0355\u0339\3\2\2\2\u0355"+ 16008 "\u033a\3\2\2\2\u0355\u033b\3\2\2\2\u0355\u033c\3\2\2\2\u0355\u033d\3\2"+ 16009 "\2\2\u0355\u033e\3\2\2\2\u0355\u033f\3\2\2\2\u0355\u0340\3\2\2\2\u0355"+ 16010 "\u0341\3\2\2\2\u0355\u0342\3\2\2\2\u0355\u0343\3\2\2\2\u0355\u0344\3\2"+ 16011 "\2\2\u0355\u0345\3\2\2\2\u0355\u0346\3\2\2\2\u0355\u0347\3\2\2\2\u0355"+ 16012 "\u0348\3\2\2\2\u0355\u0349\3\2\2\2\u0355\u034a\3\2\2\2\u0355\u034b\3\2"+ 16013 "\2\2\u0355\u034c\3\2\2\2\u0355\u034d\3\2\2\2\u0355\u034e\3\2\2\2\u0355"+ 16014 "\u0350\3\2\2\2\u0355\u0351\3\2\2\2\u0355\u0352\3\2\2\2\u0355\u0353\3\2"+ 16015 "\2\2\u0355\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357"+ 16016 "\u0358\3\2\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035b\5:"+ 16017 "\36\2\u035b=\3\2\2\2\u035c\u035d\7\7\2\2\u035d\u0364\7E\2\2\u035e\u0363"+ 16018 "\5\n\6\2\u035f\u0363\7\b\2\2\u0360\u0363\7\3\2\2\u0361\u0363\7\6\2\2\u0362"+ 16019 "\u035e\3\2\2\2\u0362\u035f\3\2\2\2\u0362\u0360\3\2\2\2\u0362\u0361\3\2"+ 16020 "\2\2\u0363\u0366\3\2\2\2\u0364\u0362\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+ 16021 "\u0367\3\2\2\2\u0366\u0364\3\2\2\2\u0367\u0368\79\2\2\u0368?\3\2\2\2\u0369"+ 16022 "\u036a\7\7\2\2\u036a\u036b\7;\2\2\u036b\u036f\7E\2\2\u036c\u036e\t\2\2"+ 16023 "\2\u036d\u036c\3\2\2\2\u036e\u0371\3\2\2\2\u036f\u036d\3\2\2\2\u036f\u0370"+ 16024 "\3\2\2\2\u0370\u0372\3\2\2\2\u0371\u036f\3\2\2\2\u0372\u0373\79\2\2\u0373"+ 16025 "A\3\2\2\2\u0374\u039c\5> \2\u0375\u039b\5\f\7\2\u0376\u039b\5j\66\2\u0377"+ 16026 "\u039b\5\22\n\2\u0378\u039b\5\30\r\2\u0379\u039b\5\36\20\2\u037a\u039b"+ 16027 "\5$\23\2\u037b\u039b\5*\26\2\u037c\u039b\5\60\31\2\u037d\u039b\5\66\34"+ 16028 "\2\u037e\u039b\5<\37\2\u037f\u039b\5H%\2\u0380\u039b\5N(\2\u0381\u039b"+ 16029 "\5T+\2\u0382\u039b\5Z.\2\u0383\u039b\5f\64\2\u0384\u039b\5`\61\2\u0385"+ 16030 "\u039b\5\16\b\2\u0386\u039b\5\24\13\2\u0387\u039b\5\32\16\2\u0388\u039b"+ 16031 "\5 \21\2\u0389\u039b\5&\24\2\u038a\u039b\5,\27\2\u038b\u039b\5\62\32\2"+ 16032 "\u038c\u039b\58\35\2\u038d\u039b\5D#\2\u038e\u039b\5J&\2\u038f\u039b\5"+ 16033 "P)\2\u0390\u039b\5V,\2\u0391\u039b\5b\62\2\u0392\u039b\5\\/\2\u0393\u0394"+ 16034 "\6\"\r\2\u0394\u039b\7\3\2\2\u0395\u039b\5\u0094K\2\u0396\u039b\7\5\2"+ 16035 "\2\u0397\u039b\7\b\2\2\u0398\u039b\5\u0096L\2\u0399\u039b\5\u0092J\2\u039a"+ 16036 "\u0375\3\2\2\2\u039a\u0376\3\2\2\2\u039a\u0377\3\2\2\2\u039a\u0378\3\2"+ 16037 "\2\2\u039a\u0379\3\2\2\2\u039a\u037a\3\2\2\2\u039a\u037b\3\2\2\2\u039a"+ 16038 "\u037c\3\2\2\2\u039a\u037d\3\2\2\2\u039a\u037e\3\2\2\2\u039a\u037f\3\2"+ 16039 "\2\2\u039a\u0380\3\2\2\2\u039a\u0381\3\2\2\2\u039a\u0382\3\2\2\2\u039a"+ 16040 "\u0383\3\2\2\2\u039a\u0384\3\2\2\2\u039a\u0385\3\2\2\2\u039a\u0386\3\2"+ 16041 "\2\2\u039a\u0387\3\2\2\2\u039a\u0388\3\2\2\2\u039a\u0389\3\2\2\2\u039a"+ 16042 "\u038a\3\2\2\2\u039a\u038b\3\2\2\2\u039a\u038c\3\2\2\2\u039a\u038d\3\2"+ 16043 "\2\2\u039a\u038e\3\2\2\2\u039a\u038f\3\2\2\2\u039a\u0390\3\2\2\2\u039a"+ 16044 "\u0391\3\2\2\2\u039a\u0392\3\2\2\2\u039a\u0393\3\2\2\2\u039a\u0395\3\2"+ 16045 "\2\2\u039a\u0396\3\2\2\2\u039a\u0397\3\2\2\2\u039a\u0398\3\2\2\2\u039a"+ 16046 "\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c\u039d\3\2"+ 16047 "\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a0\5@!\2\u03a0C"+ 16048 "\3\2\2\2\u03a1\u03a2\7\7\2\2\u03a2\u03a9\7F\2\2\u03a3\u03a8\5\n\6\2\u03a4"+ 16049 "\u03a8\7\b\2\2\u03a5\u03a8\7\3\2\2\u03a6\u03a8\7\6\2\2\u03a7\u03a3\3\2"+ 16050 "\2\2\u03a7\u03a4\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a7\u03a6\3\2\2\2\u03a8"+ 16051 "\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa\u03ac\3\2"+ 16052 "\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ad\79\2\2\u03adE\3\2\2\2\u03ae\u03af"+ 16053 "\7\7\2\2\u03af\u03b0\7;\2\2\u03b0\u03b4\7F\2\2\u03b1\u03b3\t\2\2\2\u03b2"+ 16054 "\u03b1\3\2\2\2\u03b3\u03b6\3\2\2\2\u03b4\u03b2\3\2\2\2\u03b4\u03b5\3\2"+ 16055 "\2\2\u03b5\u03b7\3\2\2\2\u03b6\u03b4\3\2\2\2\u03b7\u03b8\79\2\2\u03b8"+ 16056 "G\3\2\2\2\u03b9\u03e1\5D#\2\u03ba\u03e0\5\f\7\2\u03bb\u03e0\5j\66\2\u03bc"+ 16057 "\u03e0\5\22\n\2\u03bd\u03e0\5\30\r\2\u03be\u03e0\5\36\20\2\u03bf\u03e0"+ 16058 "\5$\23\2\u03c0\u03e0\5*\26\2\u03c1\u03e0\5\60\31\2\u03c2\u03e0\5\66\34"+ 16059 "\2\u03c3\u03e0\5<\37\2\u03c4\u03e0\5B\"\2\u03c5\u03e0\5N(\2\u03c6\u03e0"+ 16060 "\5T+\2\u03c7\u03e0\5Z.\2\u03c8\u03e0\5f\64\2\u03c9\u03e0\5`\61\2\u03ca"+ 16061 "\u03e0\5\16\b\2\u03cb\u03e0\5\24\13\2\u03cc\u03e0\5\32\16\2\u03cd\u03e0"+ 16062 "\5 \21\2\u03ce\u03e0\5&\24\2\u03cf\u03e0\5,\27\2\u03d0\u03e0\5\62\32\2"+ 16063 "\u03d1\u03e0\58\35\2\u03d2\u03e0\5> \2\u03d3\u03e0\5J&\2\u03d4\u03e0\5"+ 16064 "P)\2\u03d5\u03e0\5V,\2\u03d6\u03e0\5b\62\2\u03d7\u03e0\5\\/\2\u03d8\u03d9"+ 16065 "\6%\16\2\u03d9\u03e0\7\3\2\2\u03da\u03e0\5\u0094K\2\u03db\u03e0\7\5\2"+ 16066 "\2\u03dc\u03e0\7\b\2\2\u03dd\u03e0\5\u0096L\2\u03de\u03e0\5\u0092J\2\u03df"+ 16067 "\u03ba\3\2\2\2\u03df\u03bb\3\2\2\2\u03df\u03bc\3\2\2\2\u03df\u03bd\3\2"+ 16068 "\2\2\u03df\u03be\3\2\2\2\u03df\u03bf\3\2\2\2\u03df\u03c0\3\2\2\2\u03df"+ 16069 "\u03c1\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03c3\3\2\2\2\u03df\u03c4\3\2"+ 16070 "\2\2\u03df\u03c5\3\2\2\2\u03df\u03c6\3\2\2\2\u03df\u03c7\3\2\2\2\u03df"+ 16071 "\u03c8\3\2\2\2\u03df\u03c9\3\2\2\2\u03df\u03ca\3\2\2\2\u03df\u03cb\3\2"+ 16072 "\2\2\u03df\u03cc\3\2\2\2\u03df\u03cd\3\2\2\2\u03df\u03ce\3\2\2\2\u03df"+ 16073 "\u03cf\3\2\2\2\u03df\u03d0\3\2\2\2\u03df\u03d1\3\2\2\2\u03df\u03d2\3\2"+ 16074 "\2\2\u03df\u03d3\3\2\2\2\u03df\u03d4\3\2\2\2\u03df\u03d5\3\2\2\2\u03df"+ 16075 "\u03d6\3\2\2\2\u03df\u03d7\3\2\2\2\u03df\u03d8\3\2\2\2\u03df\u03da\3\2"+ 16076 "\2\2\u03df\u03db\3\2\2\2\u03df\u03dc\3\2\2\2\u03df\u03dd\3\2\2\2\u03df"+ 16077 "\u03de\3\2\2\2\u03e0\u03e3\3\2\2\2\u03e1\u03df\3\2\2\2\u03e1\u03e2\3\2"+ 16078 "\2\2\u03e2\u03e4\3\2\2\2\u03e3\u03e1\3\2\2\2\u03e4\u03e5\5F$\2\u03e5I"+ 16079 "\3\2\2\2\u03e6\u03e7\7\7\2\2\u03e7\u03ee\7G\2\2\u03e8\u03ed\5\n\6\2\u03e9"+ 16080 "\u03ed\7\b\2\2\u03ea\u03ed\7\3\2\2\u03eb\u03ed\7\6\2\2\u03ec\u03e8\3\2"+ 16081 "\2\2\u03ec\u03e9\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ec\u03eb\3\2\2\2\u03ed"+ 16082 "\u03f0\3\2\2\2\u03ee\u03ec\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f1\3\2"+ 16083 "\2\2\u03f0\u03ee\3\2\2\2\u03f1\u03f2\79\2\2\u03f2K\3\2\2\2\u03f3\u03f4"+ 16084 "\7\7\2\2\u03f4\u03f5\7;\2\2\u03f5\u03f9\7G\2\2\u03f6\u03f8\t\2\2\2\u03f7"+ 16085 "\u03f6\3\2\2\2\u03f8\u03fb\3\2\2\2\u03f9\u03f7\3\2\2\2\u03f9\u03fa\3\2"+ 16086 "\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03f9\3\2\2\2\u03fc\u03fd\79\2\2\u03fd"+ 16087 "M\3\2\2\2\u03fe\u0426\5J&\2\u03ff\u0425\5\f\7\2\u0400\u0425\5j\66\2\u0401"+ 16088 "\u0425\5\22\n\2\u0402\u0425\5\30\r\2\u0403\u0425\5\36\20\2\u0404\u0425"+ 16089 "\5$\23\2\u0405\u0425\5*\26\2\u0406\u0425\5\60\31\2\u0407\u0425\5\66\34"+ 16090 "\2\u0408\u0425\5<\37\2\u0409\u0425\5B\"\2\u040a\u0425\5H%\2\u040b\u0425"+ 16091 "\5T+\2\u040c\u0425\5Z.\2\u040d\u0425\5f\64\2\u040e\u0425\5`\61\2\u040f"+ 16092 "\u0425\5\16\b\2\u0410\u0425\5\24\13\2\u0411\u0425\5\32\16\2\u0412\u0425"+ 16093 "\5 \21\2\u0413\u0425\5&\24\2\u0414\u0425\5,\27\2\u0415\u0425\5\62\32\2"+ 16094 "\u0416\u0425\58\35\2\u0417\u0425\5> \2\u0418\u0425\5D#\2\u0419\u0425\5"+ 16095 "P)\2\u041a\u0425\5V,\2\u041b\u0425\5b\62\2\u041c\u0425\5\\/\2\u041d\u041e"+ 16096 "\6(\17\2\u041e\u0425\7\3\2\2\u041f\u0425\5\u0094K\2\u0420\u0425\7\5\2"+ 16097 "\2\u0421\u0425\7\b\2\2\u0422\u0425\5\u0096L\2\u0423\u0425\5\u0092J\2\u0424"+ 16098 "\u03ff\3\2\2\2\u0424\u0400\3\2\2\2\u0424\u0401\3\2\2\2\u0424\u0402\3\2"+ 16099 "\2\2\u0424\u0403\3\2\2\2\u0424\u0404\3\2\2\2\u0424\u0405\3\2\2\2\u0424"+ 16100 "\u0406\3\2\2\2\u0424\u0407\3\2\2\2\u0424\u0408\3\2\2\2\u0424\u0409\3\2"+ 16101 "\2\2\u0424\u040a\3\2\2\2\u0424\u040b\3\2\2\2\u0424\u040c\3\2\2\2\u0424"+ 16102 "\u040d\3\2\2\2\u0424\u040e\3\2\2\2\u0424\u040f\3\2\2\2\u0424\u0410\3\2"+ 16103 "\2\2\u0424\u0411\3\2\2\2\u0424\u0412\3\2\2\2\u0424\u0413\3\2\2\2\u0424"+ 16104 "\u0414\3\2\2\2\u0424\u0415\3\2\2\2\u0424\u0416\3\2\2\2\u0424\u0417\3\2"+ 16105 "\2\2\u0424\u0418\3\2\2\2\u0424\u0419\3\2\2\2\u0424\u041a\3\2\2\2\u0424"+ 16106 "\u041b\3\2\2\2\u0424\u041c\3\2\2\2\u0424\u041d\3\2\2\2\u0424\u041f\3\2"+ 16107 "\2\2\u0424\u0420\3\2\2\2\u0424\u0421\3\2\2\2\u0424\u0422\3\2\2\2\u0424"+ 16108 "\u0423\3\2\2\2\u0425\u0428\3\2\2\2\u0426\u0424\3\2\2\2\u0426\u0427\3\2"+ 16109 "\2\2\u0427\u0429\3\2\2\2\u0428\u0426\3\2\2\2\u0429\u042a\5L\'\2\u042a"+ 16110 "O\3\2\2\2\u042b\u042c\7\7\2\2\u042c\u0433\7H\2\2\u042d\u0432\5\n\6\2\u042e"+ 16111 "\u0432\7\b\2\2\u042f\u0432\7\3\2\2\u0430\u0432\7\6\2\2\u0431\u042d\3\2"+ 16112 "\2\2\u0431\u042e\3\2\2\2\u0431\u042f\3\2\2\2\u0431\u0430\3\2\2\2\u0432"+ 16113 "\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434\u0436\3\2"+ 16114 "\2\2\u0435\u0433\3\2\2\2\u0436\u0437\79\2\2\u0437Q\3\2\2\2\u0438\u0439"+ 16115 "\7\7\2\2\u0439\u043a\7;\2\2\u043a\u043e\7H\2\2\u043b\u043d\t\2\2\2\u043c"+ 16116 "\u043b\3\2\2\2\u043d\u0440\3\2\2\2\u043e\u043c\3\2\2\2\u043e\u043f\3\2"+ 16117 "\2\2\u043f\u0441\3\2\2\2\u0440\u043e\3\2\2\2\u0441\u0442\79\2\2\u0442"+ 16118 "S\3\2\2\2\u0443\u046b\5P)\2\u0444\u046a\5\f\7\2\u0445\u046a\5j\66\2\u0446"+ 16119 "\u046a\5\22\n\2\u0447\u046a\5\30\r\2\u0448\u046a\5\36\20\2\u0449\u046a"+ 16120 "\5$\23\2\u044a\u046a\5*\26\2\u044b\u046a\5\60\31\2\u044c\u046a\5\66\34"+ 16121 "\2\u044d\u046a\5<\37\2\u044e\u046a\5B\"\2\u044f\u046a\5H%\2\u0450\u046a"+ 16122 "\5N(\2\u0451\u046a\5Z.\2\u0452\u046a\5f\64\2\u0453\u046a\5`\61\2\u0454"+ 16123 "\u046a\5\16\b\2\u0455\u046a\5\24\13\2\u0456\u046a\5\32\16\2\u0457\u046a"+ 16124 "\5 \21\2\u0458\u046a\5&\24\2\u0459\u046a\5,\27\2\u045a\u046a\5\62\32\2"+ 16125 "\u045b\u046a\58\35\2\u045c\u046a\5> \2\u045d\u046a\5D#\2\u045e\u046a\5"+ 16126 "J&\2\u045f\u046a\5V,\2\u0460\u046a\5b\62\2\u0461\u046a\5\\/\2\u0462\u0463"+ 16127 "\6+\20\2\u0463\u046a\7\3\2\2\u0464\u046a\5\u0094K\2\u0465\u046a\7\5\2"+ 16128 "\2\u0466\u046a\7\b\2\2\u0467\u046a\5\u0096L\2\u0468\u046a\5\u0092J\2\u0469"+ 16129 "\u0444\3\2\2\2\u0469\u0445\3\2\2\2\u0469\u0446\3\2\2\2\u0469\u0447\3\2"+ 16130 "\2\2\u0469\u0448\3\2\2\2\u0469\u0449\3\2\2\2\u0469\u044a\3\2\2\2\u0469"+ 16131 "\u044b\3\2\2\2\u0469\u044c\3\2\2\2\u0469\u044d\3\2\2\2\u0469\u044e\3\2"+ 16132 "\2\2\u0469\u044f\3\2\2\2\u0469\u0450\3\2\2\2\u0469\u0451\3\2\2\2\u0469"+ 16133 "\u0452\3\2\2\2\u0469\u0453\3\2\2\2\u0469\u0454\3\2\2\2\u0469\u0455\3\2"+ 16134 "\2\2\u0469\u0456\3\2\2\2\u0469\u0457\3\2\2\2\u0469\u0458\3\2\2\2\u0469"+ 16135 "\u0459\3\2\2\2\u0469\u045a\3\2\2\2\u0469\u045b\3\2\2\2\u0469\u045c\3\2"+ 16136 "\2\2\u0469\u045d\3\2\2\2\u0469\u045e\3\2\2\2\u0469\u045f\3\2\2\2\u0469"+ 16137 "\u0460\3\2\2\2\u0469\u0461\3\2\2\2\u0469\u0462\3\2\2\2\u0469\u0464\3\2"+ 16138 "\2\2\u0469\u0465\3\2\2\2\u0469\u0466\3\2\2\2\u0469\u0467\3\2\2\2\u0469"+ 16139 "\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c\3\2"+ 16140 "\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u046f\5R*\2\u046fU"+ 16141 "\3\2\2\2\u0470\u0471\7\7\2\2\u0471\u0478\7I\2\2\u0472\u0477\5\n\6\2\u0473"+ 16142 "\u0477\7\b\2\2\u0474\u0477\7\3\2\2\u0475\u0477\7\6\2\2\u0476\u0472\3\2"+ 16143 "\2\2\u0476\u0473\3\2\2\2\u0476\u0474\3\2\2\2\u0476\u0475\3\2\2\2\u0477"+ 16144 "\u047a\3\2\2\2\u0478\u0476\3\2\2\2\u0478\u0479\3\2\2\2\u0479\u047b\3\2"+ 16145 "\2\2\u047a\u0478\3\2\2\2\u047b\u047c\79\2\2\u047cW\3\2\2\2\u047d\u047e"+ 16146 "\7\7\2\2\u047e\u047f\7;\2\2\u047f\u0483\7I\2\2\u0480\u0482\t\2\2\2\u0481"+ 16147 "\u0480\3\2\2\2\u0482\u0485\3\2\2\2\u0483\u0481\3\2\2\2\u0483\u0484\3\2"+ 16148 "\2\2\u0484\u0486\3\2\2\2\u0485\u0483\3\2\2\2\u0486\u0487\79\2\2\u0487"+ 16149 "Y\3\2\2\2\u0488\u04b0\5V,\2\u0489\u04af\5\f\7\2\u048a\u04af\5j\66\2\u048b"+ 16150 "\u04af\5\22\n\2\u048c\u04af\5\30\r\2\u048d\u04af\5\36\20\2\u048e\u04af"+ 16151 "\5$\23\2\u048f\u04af\5*\26\2\u0490\u04af\5\60\31\2\u0491\u04af\5\66\34"+ 16152 "\2\u0492\u04af\5<\37\2\u0493\u04af\5B\"\2\u0494\u04af\5H%\2\u0495\u04af"+ 16153 "\5N(\2\u0496\u04af\5T+\2\u0497\u04af\5f\64\2\u0498\u04af\5`\61\2\u0499"+ 16154 "\u04af\5\16\b\2\u049a\u04af\5\24\13\2\u049b\u04af\5\32\16\2\u049c\u04af"+ 16155 "\5 \21\2\u049d\u04af\5&\24\2\u049e\u04af\5,\27\2\u049f\u04af\5\62\32\2"+ 16156 "\u04a0\u04af\58\35\2\u04a1\u04af\5> \2\u04a2\u04af\5D#\2\u04a3\u04af\5"+ 16157 "J&\2\u04a4\u04af\5P)\2\u04a5\u04af\5b\62\2\u04a6\u04af\5\\/\2\u04a7\u04a8"+ 16158 "\6.\21\2\u04a8\u04af\7\3\2\2\u04a9\u04af\5\u0094K\2\u04aa\u04af\7\5\2"+ 16159 "\2\u04ab\u04af\7\b\2\2\u04ac\u04af\5\u0096L\2\u04ad\u04af\5\u0092J\2\u04ae"+ 16160 "\u0489\3\2\2\2\u04ae\u048a\3\2\2\2\u04ae\u048b\3\2\2\2\u04ae\u048c\3\2"+ 16161 "\2\2\u04ae\u048d\3\2\2\2\u04ae\u048e\3\2\2\2\u04ae\u048f\3\2\2\2\u04ae"+ 16162 "\u0490\3\2\2\2\u04ae\u0491\3\2\2\2\u04ae\u0492\3\2\2\2\u04ae\u0493\3\2"+ 16163 "\2\2\u04ae\u0494\3\2\2\2\u04ae\u0495\3\2\2\2\u04ae\u0496\3\2\2\2\u04ae"+ 16164 "\u0497\3\2\2\2\u04ae\u0498\3\2\2\2\u04ae\u0499\3\2\2\2\u04ae\u049a\3\2"+ 16165 "\2\2\u04ae\u049b\3\2\2\2\u04ae\u049c\3\2\2\2\u04ae\u049d\3\2\2\2\u04ae"+ 16166 "\u049e\3\2\2\2\u04ae\u049f\3\2\2\2\u04ae\u04a0\3\2\2\2\u04ae\u04a1\3\2"+ 16167 "\2\2\u04ae\u04a2\3\2\2\2\u04ae\u04a3\3\2\2\2\u04ae\u04a4\3\2\2\2\u04ae"+ 16168 "\u04a5\3\2\2\2\u04ae\u04a6\3\2\2\2\u04ae\u04a7\3\2\2\2\u04ae\u04a9\3\2"+ 16169 "\2\2\u04ae\u04aa\3\2\2\2\u04ae\u04ab\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae"+ 16170 "\u04ad\3\2\2\2\u04af\u04b2\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b0\u04b1\3\2"+ 16171 "\2\2\u04b1\u04b3\3\2\2\2\u04b2\u04b0\3\2\2\2\u04b3\u04b4\5X-\2\u04b4["+ 16172 "\3\2\2\2\u04b5\u04b6\7\7\2\2\u04b6\u04bd\7J\2\2\u04b7\u04bc\5\n\6\2\u04b8"+ 16173 "\u04bc\7\b\2\2\u04b9\u04bc\7\3\2\2\u04ba\u04bc\7\6\2\2\u04bb\u04b7\3\2"+ 16174 "\2\2\u04bb\u04b8\3\2\2\2\u04bb\u04b9\3\2\2\2\u04bb\u04ba\3\2\2\2\u04bc"+ 16175 "\u04bf\3\2\2\2\u04bd\u04bb\3\2\2\2\u04bd\u04be\3\2\2\2\u04be\u04c0\3\2"+ 16176 "\2\2\u04bf\u04bd\3\2\2\2\u04c0\u04c1\79\2\2\u04c1]\3\2\2\2\u04c2\u04c3"+ 16177 "\7\7\2\2\u04c3\u04c4\7;\2\2\u04c4\u04c8\7J\2\2\u04c5\u04c7\t\2\2\2\u04c6"+ 16178 "\u04c5\3\2\2\2\u04c7\u04ca\3\2\2\2\u04c8\u04c6\3\2\2\2\u04c8\u04c9\3\2"+ 16179 "\2\2\u04c9\u04cb\3\2\2\2\u04ca\u04c8\3\2\2\2\u04cb\u04cc\79\2\2\u04cc"+ 16180 "_\3\2\2\2\u04cd\u04f5\5\\/\2\u04ce\u04f4\5\f\7\2\u04cf\u04f4\5j\66\2\u04d0"+ 16181 "\u04f4\5\22\n\2\u04d1\u04f4\5\30\r\2\u04d2\u04f4\5\36\20\2\u04d3\u04f4"+ 16182 "\5$\23\2\u04d4\u04f4\5*\26\2\u04d5\u04f4\5\60\31\2\u04d6\u04f4\5\66\34"+ 16183 "\2\u04d7\u04f4\5<\37\2\u04d8\u04f4\5B\"\2\u04d9\u04f4\5H%\2\u04da\u04f4"+ 16184 "\5N(\2\u04db\u04f4\5T+\2\u04dc\u04f4\5Z.\2\u04dd\u04f4\5f\64\2\u04de\u04f4"+ 16185 "\5\16\b\2\u04df\u04f4\5\24\13\2\u04e0\u04f4\5\32\16\2\u04e1\u04f4\5 \21"+ 16186 "\2\u04e2\u04f4\5&\24\2\u04e3\u04f4\5,\27\2\u04e4\u04f4\5\62\32\2\u04e5"+ 16187 "\u04f4\58\35\2\u04e6\u04f4\5> \2\u04e7\u04f4\5D#\2\u04e8\u04f4\5J&\2\u04e9"+ 16188 "\u04f4\5P)\2\u04ea\u04f4\5V,\2\u04eb\u04f4\5b\62\2\u04ec\u04ed\6\61\22"+ 16189 "\2\u04ed\u04f4\7\3\2\2\u04ee\u04f4\5\u0094K\2\u04ef\u04f4\7\5\2\2\u04f0"+ 16190 "\u04f4\7\b\2\2\u04f1\u04f4\5\u0096L\2\u04f2\u04f4\5\u0092J\2\u04f3\u04ce"+ 16191 "\3\2\2\2\u04f3\u04cf\3\2\2\2\u04f3\u04d0\3\2\2\2\u04f3\u04d1\3\2\2\2\u04f3"+ 16192 "\u04d2\3\2\2\2\u04f3\u04d3\3\2\2\2\u04f3\u04d4\3\2\2\2\u04f3\u04d5\3\2"+ 16193 "\2\2\u04f3\u04d6\3\2\2\2\u04f3\u04d7\3\2\2\2\u04f3\u04d8\3\2\2\2\u04f3"+ 16194 "\u04d9\3\2\2\2\u04f3\u04da\3\2\2\2\u04f3\u04db\3\2\2\2\u04f3\u04dc\3\2"+ 16195 "\2\2\u04f3\u04dd\3\2\2\2\u04f3\u04de\3\2\2\2\u04f3\u04df\3\2\2\2\u04f3"+ 16196 "\u04e0\3\2\2\2\u04f3\u04e1\3\2\2\2\u04f3\u04e2\3\2\2\2\u04f3\u04e3\3\2"+ 16197 "\2\2\u04f3\u04e4\3\2\2\2\u04f3\u04e5\3\2\2\2\u04f3\u04e6\3\2\2\2\u04f3"+ 16198 "\u04e7\3\2\2\2\u04f3\u04e8\3\2\2\2\u04f3\u04e9\3\2\2\2\u04f3\u04ea\3\2"+ 16199 "\2\2\u04f3\u04eb\3\2\2\2\u04f3\u04ec\3\2\2\2\u04f3\u04ee\3\2\2\2\u04f3"+ 16200 "\u04ef\3\2\2\2\u04f3\u04f0\3\2\2\2\u04f3\u04f1\3\2\2\2\u04f3\u04f2\3\2"+ 16201 "\2\2\u04f4\u04f7\3\2\2\2\u04f5\u04f3\3\2\2\2\u04f5\u04f6\3\2\2\2\u04f6"+ 16202 "\u04f8\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f8\u04f9\5^\60\2\u04f9a\3\2\2\2"+ 16203 "\u04fa\u04fb\7\7\2\2\u04fb\u0502\7K\2\2\u04fc\u0501\5\n\6\2\u04fd\u0501"+ 16204 "\7\b\2\2\u04fe\u0501\7\3\2\2\u04ff\u0501\7\6\2\2\u0500\u04fc\3\2\2\2\u0500"+ 16205 "\u04fd\3\2\2\2\u0500\u04fe\3\2\2\2\u0500\u04ff\3\2\2\2\u0501\u0504\3\2"+ 16206 "\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0505\3\2\2\2\u0504"+ 16207 "\u0502\3\2\2\2\u0505\u0506\79\2\2\u0506c\3\2\2\2\u0507\u0508\7\7\2\2\u0508"+ 16208 "\u0509\7;\2\2\u0509\u050d\7K\2\2\u050a\u050c\t\2\2\2\u050b\u050a\3\2\2"+ 16209 "\2\u050c\u050f\3\2\2\2\u050d\u050b\3\2\2\2\u050d\u050e\3\2\2\2\u050e\u0510"+ 16210 "\3\2\2\2\u050f\u050d\3\2\2\2\u0510\u0511\79\2\2\u0511e\3\2\2\2\u0512\u053a"+ 16211 "\5b\62\2\u0513\u0539\5\f\7\2\u0514\u0539\5j\66\2\u0515\u0539\5\22\n\2"+ 16212 "\u0516\u0539\5\30\r\2\u0517\u0539\5\36\20\2\u0518\u0539\5$\23\2\u0519"+ 16213 "\u0539\5*\26\2\u051a\u0539\5\60\31\2\u051b\u0539\5\66\34\2\u051c\u0539"+ 16214 "\5<\37\2\u051d\u0539\5B\"\2\u051e\u0539\5H%\2\u051f\u0539\5N(\2\u0520"+ 16215 "\u0539\5T+\2\u0521\u0539\5Z.\2\u0522\u0539\5`\61\2\u0523\u0539\5\16\b"+ 16216 "\2\u0524\u0539\5\24\13\2\u0525\u0539\5\32\16\2\u0526\u0539\5 \21\2\u0527"+ 16217 "\u0539\5&\24\2\u0528\u0539\5,\27\2\u0529\u0539\5\62\32\2\u052a\u0539\5"+ 16218 "8\35\2\u052b\u0539\5> \2\u052c\u0539\5D#\2\u052d\u0539\5J&\2\u052e\u0539"+ 16219 "\5P)\2\u052f\u0539\5V,\2\u0530\u0539\5\\/\2\u0531\u0532\6\64\23\2\u0532"+ 16220 "\u0539\7\3\2\2\u0533\u0539\5\u0094K\2\u0534\u0539\7\5\2\2\u0535\u0539"+ 16221 "\7\b\2\2\u0536\u0539\5\u0096L\2\u0537\u0539\5\u0092J\2\u0538\u0513\3\2"+ 16222 "\2\2\u0538\u0514\3\2\2\2\u0538\u0515\3\2\2\2\u0538\u0516\3\2\2\2\u0538"+ 16223 "\u0517\3\2\2\2\u0538\u0518\3\2\2\2\u0538\u0519\3\2\2\2\u0538\u051a\3\2"+ 16224 "\2\2\u0538\u051b\3\2\2\2\u0538\u051c\3\2\2\2\u0538\u051d\3\2\2\2\u0538"+ 16225 "\u051e\3\2\2\2\u0538\u051f\3\2\2\2\u0538\u0520\3\2\2\2\u0538\u0521\3\2"+ 16226 "\2\2\u0538\u0522\3\2\2\2\u0538\u0523\3\2\2\2\u0538\u0524\3\2\2\2\u0538"+ 16227 "\u0525\3\2\2\2\u0538\u0526\3\2\2\2\u0538\u0527\3\2\2\2\u0538\u0528\3\2"+ 16228 "\2\2\u0538\u0529\3\2\2\2\u0538\u052a\3\2\2\2\u0538\u052b\3\2\2\2\u0538"+ 16229 "\u052c\3\2\2\2\u0538\u052d\3\2\2\2\u0538\u052e\3\2\2\2\u0538\u052f\3\2"+ 16230 "\2\2\u0538\u0530\3\2\2\2\u0538\u0531\3\2\2\2\u0538\u0533\3\2\2\2\u0538"+ 16231 "\u0534\3\2\2\2\u0538\u0535\3\2\2\2\u0538\u0536\3\2\2\2\u0538\u0537\3\2"+ 16232 "\2\2\u0539\u053c\3\2\2\2\u053a\u0538\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+ 16233 "\u053d\3\2\2\2\u053c\u053a\3\2\2\2\u053d\u053e\5d\63\2\u053eg\3\2\2\2"+ 16234 "\u053f\u054f\5j\66\2\u0540\u054f\5l\67\2\u0541\u054f\5n8\2\u0542\u054f"+ 16235 "\5p9\2\u0543\u054f\5r:\2\u0544\u054f\5t;\2\u0545\u054f\5v<\2\u0546\u054f"+ 16236 "\5x=\2\u0547\u054f\5z>\2\u0548\u054f\5|?\2\u0549\u054f\5~@\2\u054a\u054f"+ 16237 "\5\u0080A\2\u054b\u054f\5\u0082B\2\u054c\u054f\5\u0084C\2\u054d\u054f"+ 16238 "\5\u0086D\2\u054e\u053f\3\2\2\2\u054e\u0540\3\2\2\2\u054e\u0541\3\2\2"+ 16239 "\2\u054e\u0542\3\2\2\2\u054e\u0543\3\2\2\2\u054e\u0544\3\2\2\2\u054e\u0545"+ 16240 "\3\2\2\2\u054e\u0546\3\2\2\2\u054e\u0547\3\2\2\2\u054e\u0548\3\2\2\2\u054e"+ 16241 "\u0549\3\2\2\2\u054e\u054a\3\2\2\2\u054e\u054b\3\2\2\2\u054e\u054c\3\2"+ 16242 "\2\2\u054e\u054d\3\2\2\2\u054fi\3\2\2\2\u0550\u0551\7\7\2\2\u0551\u0558"+ 16243 "\t\3\2\2\u0552\u0557\5\n\6\2\u0553\u0557\7\b\2\2\u0554\u0557\7\3\2\2\u0555"+ 16244 "\u0557\7\6\2\2\u0556\u0552\3\2\2\2\u0556\u0553\3\2\2\2\u0556\u0554\3\2"+ 16245 "\2\2\u0556\u0555\3\2\2\2\u0557\u055a\3\2\2\2\u0558\u0556\3\2\2\2\u0558"+ 16246 "\u0559\3\2\2\2\u0559\u055b\3\2\2\2\u055a\u0558\3\2\2\2\u055b\u055c\7:"+ 16247 "\2\2\u055ck\3\2\2\2\u055d\u055e\7\7\2\2\u055e\u0565\7L\2\2\u055f\u0564"+ 16248 "\5\n\6\2\u0560\u0564\7\b\2\2\u0561\u0564\7\3\2\2\u0562\u0564\7\6\2\2\u0563"+ 16249 "\u055f\3\2\2\2\u0563\u0560\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0562\3\2"+ 16250 "\2\2\u0564\u0567\3\2\2\2\u0565\u0563\3\2\2\2\u0565\u0566\3\2\2\2\u0566"+ 16251 "\u0568\3\2\2\2\u0567\u0565\3\2\2\2\u0568\u0569\t\4\2\2\u0569m\3\2\2\2"+ 16252 "\u056a\u056b\7\7\2\2\u056b\u0572\7M\2\2\u056c\u0571\5\n\6\2\u056d\u0571"+ 16253 "\7\b\2\2\u056e\u0571\7\3\2\2\u056f\u0571\7\6\2\2\u0570\u056c\3\2\2\2\u0570"+ 16254 "\u056d\3\2\2\2\u0570\u056e\3\2\2\2\u0570\u056f\3\2\2\2\u0571\u0574\3\2"+ 16255 "\2\2\u0572\u0570\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u0575\3\2\2\2\u0574"+ 16256 "\u0572\3\2\2\2\u0575\u0576\t\4\2\2\u0576o\3\2\2\2\u0577\u0578\7\7\2\2"+ 16257 "\u0578\u057f\7N\2\2\u0579\u057e\5\n\6\2\u057a\u057e\7\b\2\2\u057b\u057e"+ 16258 "\7\3\2\2\u057c\u057e\7\6\2\2\u057d\u0579\3\2\2\2\u057d\u057a\3\2\2\2\u057d"+ 16259 "\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e\u0581\3\2\2\2\u057f\u057d\3\2"+ 16260 "\2\2\u057f\u0580\3\2\2\2\u0580\u0582\3\2\2\2\u0581\u057f\3\2\2\2\u0582"+ 16261 "\u0583\t\4\2\2\u0583q\3\2\2\2\u0584\u0585\7\7\2\2\u0585\u058c\7O\2\2\u0586"+ 16262 "\u058b\5\n\6\2\u0587\u058b\7\b\2\2\u0588\u058b\7\3\2\2\u0589\u058b\7\6"+ 16263 "\2\2\u058a\u0586\3\2\2\2\u058a\u0587\3\2\2\2\u058a\u0588\3\2\2\2\u058a"+ 16264 "\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2\2\2\u058c\u058d\3\2"+ 16265 "\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f\u0590\t\4\2\2\u0590"+ 16266 "s\3\2\2\2\u0591\u0592\7\7\2\2\u0592\u0599\7P\2\2\u0593\u0598\5\n\6\2\u0594"+ 16267 "\u0598\7\b\2\2\u0595\u0598\7\3\2\2\u0596\u0598\7\6\2\2\u0597\u0593\3\2"+ 16268 "\2\2\u0597\u0594\3\2\2\2\u0597\u0595\3\2\2\2\u0597\u0596\3\2\2\2\u0598"+ 16269 "\u059b\3\2\2\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u059c\3\2"+ 16270 "\2\2\u059b\u0599\3\2\2\2\u059c\u059d\t\4\2\2\u059du\3\2\2\2\u059e\u059f"+ 16271 "\7\7\2\2\u059f\u05a6\7Q\2\2\u05a0\u05a5\5\n\6\2\u05a1\u05a5\7\b\2\2\u05a2"+ 16272 "\u05a5\7\3\2\2\u05a3\u05a5\7\6\2\2\u05a4\u05a0\3\2\2\2\u05a4\u05a1\3\2"+ 16273 "\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3\3\2\2\2\u05a5\u05a8\3\2\2\2\u05a6"+ 16274 "\u05a4\3\2\2\2\u05a6\u05a7\3\2\2\2\u05a7\u05a9\3\2\2\2\u05a8\u05a6\3\2"+ 16275 "\2\2\u05a9\u05aa\t\4\2\2\u05aaw\3\2\2\2\u05ab\u05ac\7\7\2\2\u05ac\u05b3"+ 16276 "\7R\2\2\u05ad\u05b2\5\n\6\2\u05ae\u05b2\7\b\2\2\u05af\u05b2\7\3\2\2\u05b0"+ 16277 "\u05b2\7\6\2\2\u05b1\u05ad\3\2\2\2\u05b1\u05ae\3\2\2\2\u05b1\u05af\3\2"+ 16278 "\2\2\u05b1\u05b0\3\2\2\2\u05b2\u05b5\3\2\2\2\u05b3\u05b1\3\2\2\2\u05b3"+ 16279 "\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b3\3\2\2\2\u05b6\u05b7\t\4"+ 16280 "\2\2\u05b7y\3\2\2\2\u05b8\u05b9\7\7\2\2\u05b9\u05c0\7S\2\2\u05ba\u05bf"+ 16281 "\5\n\6\2\u05bb\u05bf\7\b\2\2\u05bc\u05bf\7\3\2\2\u05bd\u05bf\7\6\2\2\u05be"+ 16282 "\u05ba\3\2\2\2\u05be\u05bb\3\2\2\2\u05be\u05bc\3\2\2\2\u05be\u05bd\3\2"+ 16283 "\2\2\u05bf\u05c2\3\2\2\2\u05c0\u05be\3\2\2\2\u05c0\u05c1\3\2\2\2\u05c1"+ 16284 "\u05c3\3\2\2\2\u05c2\u05c0\3\2\2\2\u05c3\u05c4\t\4\2\2\u05c4{\3\2\2\2"+ 16285 "\u05c5\u05c6\7\7\2\2\u05c6\u05cd\7T\2\2\u05c7\u05cc\5\n\6\2\u05c8\u05cc"+ 16286 "\7\b\2\2\u05c9\u05cc\7\3\2\2\u05ca\u05cc\7\6\2\2\u05cb\u05c7\3\2\2\2\u05cb"+ 16287 "\u05c8\3\2\2\2\u05cb\u05c9\3\2\2\2\u05cb\u05ca\3\2\2\2\u05cc\u05cf\3\2"+ 16288 "\2\2\u05cd\u05cb\3\2\2\2\u05cd\u05ce\3\2\2\2\u05ce\u05d0\3\2\2\2\u05cf"+ 16289 "\u05cd\3\2\2\2\u05d0\u05d1\t\4\2\2\u05d1}\3\2\2\2\u05d2\u05d3\7\7\2\2"+ 16290 "\u05d3\u05da\7U\2\2\u05d4\u05d9\5\n\6\2\u05d5\u05d9\7\b\2\2\u05d6\u05d9"+ 16291 "\7\3\2\2\u05d7\u05d9\7\6\2\2\u05d8\u05d4\3\2\2\2\u05d8\u05d5\3\2\2\2\u05d8"+ 16292 "\u05d6\3\2\2\2\u05d8\u05d7\3\2\2\2\u05d9\u05dc\3\2\2\2\u05da\u05d8\3\2"+ 16293 "\2\2\u05da\u05db\3\2\2\2\u05db\u05dd\3\2\2\2\u05dc\u05da\3\2\2\2\u05dd"+ 16294 "\u05de\t\4\2\2\u05de\177\3\2\2\2\u05df\u05e0\7\7\2\2\u05e0\u05e7\7V\2"+ 16295 "\2\u05e1\u05e6\5\n\6\2\u05e2\u05e6\7\b\2\2\u05e3\u05e6\7\3\2\2\u05e4\u05e6"+ 16296 "\7\6\2\2\u05e5\u05e1\3\2\2\2\u05e5\u05e2\3\2\2\2\u05e5\u05e3\3\2\2\2\u05e5"+ 16297 "\u05e4\3\2\2\2\u05e6\u05e9\3\2\2\2\u05e7\u05e5\3\2\2\2\u05e7\u05e8\3\2"+ 16298 "\2\2\u05e8\u05ea\3\2\2\2\u05e9\u05e7\3\2\2\2\u05ea\u05eb\t\4\2\2\u05eb"+ 16299 "\u0081\3\2\2\2\u05ec\u05ed\7\7\2\2\u05ed\u05f4\7W\2\2\u05ee\u05f3\5\n"+ 16300 "\6\2\u05ef\u05f3\7\b\2\2\u05f0\u05f3\7\3\2\2\u05f1\u05f3\7\6\2\2\u05f2"+ 16301 "\u05ee\3\2\2\2\u05f2\u05ef\3\2\2\2\u05f2\u05f0\3\2\2\2\u05f2\u05f1\3\2"+ 16302 "\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4\u05f5\3\2\2\2\u05f5"+ 16303 "\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\t\4\2\2\u05f8\u0083\3\2"+ 16304 "\2\2\u05f9\u05fa\7\7\2\2\u05fa\u0601\7X\2\2\u05fb\u0600\5\n\6\2\u05fc"+ 16305 "\u0600\7\b\2\2\u05fd\u0600\7\3\2\2\u05fe\u0600\7\6\2\2\u05ff\u05fb\3\2"+ 16306 "\2\2\u05ff\u05fc\3\2\2\2\u05ff\u05fd\3\2\2\2\u05ff\u05fe\3\2\2\2\u0600"+ 16307 "\u0603\3\2\2\2\u0601\u05ff\3\2\2\2\u0601\u0602\3\2\2\2\u0602\u0604\3\2"+ 16308 "\2\2\u0603\u0601\3\2\2\2\u0604\u0605\t\4\2\2\u0605\u0085\3\2\2\2\u0606"+ 16309 "\u0607\7\7\2\2\u0607\u0608\7;\2\2\u0608\u0609\5\u0088E\2\u0609\u060a\7"+ 16310 "9\2\2\u060a\u060b\bD\1\2\u060b\u0087\3\2\2\2\u060c\u060d\t\5\2\2\u060d"+ 16311 "\u0089\3\2\2\2\u060e\u060f\6F\24\2\u060f\u0617\7\3\2\2\u0610\u0617\5\u0094"+ 16312 "K\2\u0611\u0617\7\5\2\2\u0612\u0617\7\b\2\2\u0613\u0617\5\u0096L\2\u0614"+ 16313 "\u0617\5\u0092J\2\u0615\u0617\5\4\3\2\u0616\u060e\3\2\2\2\u0616\u0610"+ 16314 "\3\2\2\2\u0616\u0611\3\2\2\2\u0616\u0612\3\2\2\2\u0616\u0613\3\2\2\2\u0616"+ 16315 "\u0614\3\2\2\2\u0616\u0615\3\2\2\2\u0617\u0618\3\2\2\2\u0618\u0616\3\2"+ 16316 "\2\2\u0618\u0619\3\2\2\2\u0619\u008b\3\2\2\2\u061a\u061e\7\36\2\2\u061b"+ 16317 "\u061d\t\6\2\2\u061c\u061b\3\2\2\2\u061d\u0620\3\2\2\2\u061e\u061c\3\2"+ 16318 "\2\2\u061e\u061f\3\2\2\2\u061f\u0622\3\2\2\2\u0620\u061e\3\2\2\2\u0621"+ 16319 "\u0623\7 \2\2\u0622\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2"+ 16320 "\2\2\u0624\u0626\7#\2\2\u0625\u0624\3\2\2\2\u0625\u0626\3\2\2\2\u0626"+ 16321 "\u0628\3\2\2\2\u0627\u0629\5\u008eH\2\u0628\u0627\3\2\2\2\u0628\u0629"+ 16322 "\3\2\2\2\u0629\u0640\3\2\2\2\u062a\u062c\t\6\2\2\u062b\u062a\3\2\2\2\u062c"+ 16323 "\u062d\3\2\2\2\u062d\u062b\3\2\2\2\u062d\u062e\3\2\2\2\u062e\u0630\3\2"+ 16324 "\2\2\u062f\u0631\7 \2\2\u0630\u062f\3\2\2\2\u0630\u0631\3\2\2\2\u0631"+ 16325 "\u0633\3\2\2\2\u0632\u0634\7#\2\2\u0633\u0632\3\2\2\2\u0633\u0634\3\2"+ 16326 "\2\2\u0634\u0636\3\2\2\2\u0635\u0637\5\u008eH\2\u0636\u0635\3\2\2\2\u0636"+ 16327 "\u0637\3\2\2\2\u0637\u0640\3\2\2\2\u0638\u063a\7 \2\2\u0639\u0638\3\2"+ 16328 "\2\2\u0639\u063a\3\2\2\2\u063a\u063b\3\2\2\2\u063b\u063d\7#\2\2\u063c"+ 16329 "\u063e\5\u008eH\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u0640"+ 16330 "\3\2\2\2\u063f\u061a\3\2\2\2\u063f\u062b\3\2\2\2\u063f\u0639\3\2\2\2\u0640"+ 16331 "\u008d\3\2\2\2\u0641\u0645\7$\2\2\u0642\u0644\t\7\2\2\u0643\u0642\3\2"+ 16332 "\2\2\u0644\u0647\3\2\2\2\u0645\u0643\3\2\2\2\u0645\u0646\3\2\2\2\u0646"+ 16333 "\u0648\3\2\2\2\u0647\u0645\3\2\2\2\u0648\u0649\7%\2\2\u0649\u008f\3\2"+ 16334 "\2\2\u064a\u064e\7\t\2\2\u064b\u064d\t\b\2\2\u064c\u064b\3\2\2\2\u064d"+ 16335 "\u0650\3\2\2\2\u064e\u064c\3\2\2\2\u064e\u064f\3\2\2\2\u064f\u0652\3\2"+ 16336 "\2\2\u0650\u064e\3\2\2\2\u0651\u0653\5\u008aF\2\u0652\u0651\3\2\2\2\u0652"+ 16337 "\u0653\3\2\2\2\u0653\u070d\3\2\2\2\u0654\u0658\7\n\2\2\u0655\u0657\t\b"+ 16338 "\2\2\u0656\u0655\3\2\2\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2\2\2\u0658"+ 16339 "\u0659\3\2\2\2\u0659\u065c\3\2\2\2\u065a\u0658\3\2\2\2\u065b\u065d\5\u008a"+ 16340 "F\2\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d\u070d\3\2\2\2\u065e"+ 16341 "\u0662\7\13\2\2\u065f\u0661\t\b\2\2\u0660\u065f\3\2\2\2\u0661\u0664\3"+ 16342 "\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663\u0666\3\2\2\2\u0664"+ 16343 "\u0662\3\2\2\2\u0665\u0667\7-\2\2\u0666\u0665\3\2\2\2\u0666\u0667\3\2"+ 16344 "\2\2\u0667\u066b\3\2\2\2\u0668\u066a\t\b\2\2\u0669\u0668\3\2\2\2\u066a"+ 16345 "\u066d\3\2\2\2\u066b\u0669\3\2\2\2\u066b\u066c\3\2\2\2\u066c\u066f\3\2"+ 16346 "\2\2\u066d\u066b\3\2\2\2\u066e\u0670\5\u008aF\2\u066f\u066e\3\2\2\2\u066f"+ 16347 "\u0670\3\2\2\2\u0670\u070d\3\2\2\2\u0671\u0675\7\f\2\2\u0672\u0674\t\b"+ 16348 "\2\2\u0673\u0672\3\2\2\2\u0674\u0677\3\2\2\2\u0675\u0673\3\2\2\2\u0675"+ 16349 "\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0675\3\2\2\2\u0678\u067a\7\33"+ 16350 "\2\2\u0679\u0678\3\2\2\2\u0679\u067a\3\2\2\2\u067a\u067e\3\2\2\2\u067b"+ 16351 "\u067d\t\b\2\2\u067c\u067b\3\2\2\2\u067d\u0680\3\2\2\2\u067e\u067c\3\2"+ 16352 "\2\2\u067e\u067f\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e\3\2\2\2\u0681"+ 16353 "\u0683\5\u008aF\2\u0682\u0681\3\2\2\2\u0682\u0683\3\2\2\2\u0683\u070d"+ 16354 "\3\2\2\2\u0684\u0688\7\r\2\2\u0685\u0687\t\b\2\2\u0686\u0685\3\2\2\2\u0687"+ 16355 "\u068a\3\2\2\2\u0688\u0686\3\2\2\2\u0688\u0689\3\2\2\2\u0689\u068c\3\2"+ 16356 "\2\2\u068a\u0688\3\2\2\2\u068b\u068d\5\u008aF\2\u068c\u068b\3\2\2\2\u068c"+ 16357 "\u068d\3\2\2\2\u068d\u070d\3\2\2\2\u068e\u0692\7\16\2\2\u068f\u0691\t"+ 16358 "\b\2\2\u0690\u068f\3\2\2\2\u0691\u0694\3\2\2\2\u0692\u0690\3\2\2\2\u0692"+ 16359 "\u0693\3\2\2\2\u0693\u0696\3\2\2\2\u0694\u0692\3\2\2\2\u0695\u0697\5\u008c"+ 16360 "G\2\u0696\u0695\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069c\3\2\2\2\u0698"+ 16361 "\u069b\7\35\2\2\u0699\u069b\5\4\3\2\u069a\u0698\3\2\2\2\u069a\u0699\3"+ 16362 "\2\2\2\u069b\u069e\3\2\2\2\u069c\u069a\3\2\2\2\u069c\u069d\3\2\2\2\u069d"+ 16363 "\u06a2\3\2\2\2\u069e\u069c\3\2\2\2\u069f\u06a1\t\b\2\2\u06a0\u069f\3\2"+ 16364 "\2\2\u06a1\u06a4\3\2\2\2\u06a2\u06a0\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3"+ 16365 "\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a5\u06a7\5\u008aF\2\u06a6\u06a5"+ 16366 "\3\2\2\2\u06a6\u06a7\3\2\2\2\u06a7\u070d\3\2\2\2\u06a8\u06ac\7\17\2\2"+ 16367 "\u06a9\u06ab\t\b\2\2\u06aa\u06a9\3\2\2\2\u06ab\u06ae\3\2\2\2\u06ac\u06aa"+ 16368 "\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06b0\3\2\2\2\u06ae\u06ac\3\2\2\2\u06af"+ 16369 "\u06b1\t\t\2\2\u06b0\u06af\3\2\2\2\u06b0\u06b1\3\2\2\2\u06b1\u06b3\3\2"+ 16370 "\2\2\u06b2\u06b4\5\u008aF\2\u06b3\u06b2\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4"+ 16371 "\u070d\3\2\2\2\u06b5\u06b9\7\21\2\2\u06b6\u06b8\t\b\2\2\u06b7\u06b6\3"+ 16372 "\2\2\2\u06b8\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba"+ 16373 "\u06bd\3\2\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5\u008aF\2\u06bd\u06bc"+ 16374 "\3\2\2\2\u06bd\u06be\3\2\2\2\u06be\u070d\3\2\2\2\u06bf\u06c3\7\20\2\2"+ 16375 "\u06c0\u06c2\t\b\2\2\u06c1\u06c0\3\2\2\2\u06c2\u06c5\3\2\2\2\u06c3\u06c1"+ 16376 "\3\2\2\2\u06c3\u06c4\3\2\2\2\u06c4\u06c7\3\2\2\2\u06c5\u06c3\3\2\2\2\u06c6"+ 16377 "\u06c8\7)\2\2\u06c7\u06c6\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06cc\3\2"+ 16378 "\2\2\u06c9\u06cb\t\b\2\2\u06ca\u06c9\3\2\2\2\u06cb\u06ce\3\2\2\2\u06cc"+ 16379 "\u06ca\3\2\2\2\u06cc\u06cd\3\2\2\2\u06cd\u06d0\3\2\2\2\u06ce\u06cc\3\2"+ 16380 "\2\2\u06cf\u06d1\7+\2\2\u06d0\u06cf\3\2\2\2\u06d0\u06d1\3\2\2\2\u06d1"+ 16381 "\u06d5\3\2\2\2\u06d2\u06d4\t\b\2\2\u06d3\u06d2\3\2\2\2\u06d4\u06d7\3\2"+ 16382 "\2\2\u06d5\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d9\3\2\2\2\u06d7"+ 16383 "\u06d5\3\2\2\2\u06d8\u06da\5\u008aF\2\u06d9\u06d8\3\2\2\2\u06d9\u06da"+ 16384 "\3\2\2\2\u06da\u070d\3\2\2\2\u06db\u06df\7\22\2\2\u06dc\u06de\t\b\2\2"+ 16385 "\u06dd\u06dc\3\2\2\2\u06de\u06e1\3\2\2\2\u06df\u06dd\3\2\2\2\u06df\u06e0"+ 16386 "\3\2\2\2\u06e0\u06e3\3\2\2\2\u06e1\u06df\3\2\2\2\u06e2\u06e4\5\u008aF"+ 16387 "\2\u06e3\u06e2\3\2\2\2\u06e3\u06e4\3\2\2\2\u06e4\u070d\3\2\2\2\u06e5\u06e9"+ 16388 "\7\23\2\2\u06e6\u06e8\t\b\2\2\u06e7\u06e6\3\2\2\2\u06e8\u06eb\3\2\2\2"+ 16389 "\u06e9\u06e7\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06ed\3\2\2\2\u06eb\u06e9"+ 16390 "\3\2\2\2\u06ec\u06ee\7-\2\2\u06ed\u06ec\3\2\2\2\u06ed\u06ee\3\2\2\2\u06ee"+ 16391 "\u06f2\3\2\2\2\u06ef\u06f1\t\b\2\2\u06f0\u06ef\3\2\2\2\u06f1\u06f4\3\2"+ 16392 "\2\2\u06f2\u06f0\3\2\2\2\u06f2\u06f3\3\2\2\2\u06f3\u06f6\3\2\2\2\u06f4"+ 16393 "\u06f2\3\2\2\2\u06f5\u06f7\5\u008aF\2\u06f6\u06f5\3\2\2\2\u06f6\u06f7"+ 16394 "\3\2\2\2\u06f7\u070d\3\2\2\2\u06f8\u06fc\7\24\2\2\u06f9\u06fb\t\b\2\2"+ 16395 "\u06fa\u06f9\3\2\2\2\u06fb\u06fe\3\2\2\2\u06fc\u06fa\3\2\2\2\u06fc\u06fd"+ 16396 "\3\2\2\2\u06fd\u0700\3\2\2\2\u06fe\u06fc\3\2\2\2\u06ff\u0701\5\u008aF"+ 16397 "\2\u0700\u06ff\3\2\2\2\u0700\u0701\3\2\2\2\u0701\u070d\3\2\2\2\u0702\u0706"+ 16398 "\7\27\2\2\u0703\u0705\t\b\2\2\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2"+ 16399 "\u0706\u0704\3\2\2\2\u0706\u0707\3\2\2\2\u0707\u070a\3\2\2\2\u0708\u0706"+ 16400 "\3\2\2\2\u0709\u070b\5\u008aF\2\u070a\u0709\3\2\2\2\u070a\u070b\3\2\2"+ 16401 "\2\u070b\u070d\3\2\2\2\u070c\u064a\3\2\2\2\u070c\u0654\3\2\2\2\u070c\u065e"+ 16402 "\3\2\2\2\u070c\u0671\3\2\2\2\u070c\u0684\3\2\2\2\u070c\u068e\3\2\2\2\u070c"+ 16403 "\u06a8\3\2\2\2\u070c\u06b5\3\2\2\2\u070c\u06bf\3\2\2\2\u070c\u06db\3\2"+ 16404 "\2\2\u070c\u06e5\3\2\2\2\u070c\u06f8\3\2\2\2\u070c\u0702\3\2\2\2\u070d"+ 16405 "\u0091\3\2\2\2\u070e\u075b\7\25\2\2\u070f\u0716\7/\2\2\u0710\u0715\7\6"+ 16406 "\2\2\u0711\u0715\7\b\2\2\u0712\u0715\7\3\2\2\u0713\u0715\5\u0096L\2\u0714"+ 16407 "\u0710\3\2\2\2\u0714\u0711\3\2\2\2\u0714\u0712\3\2\2\2\u0714\u0713\3\2"+ 16408 "\2\2\u0715\u0718\3\2\2\2\u0716\u0714\3\2\2\2\u0716\u0717\3\2\2\2\u0717"+ 16409 "\u075c\3\2\2\2\u0718\u0716\3\2\2\2\u0719\u071d\7\60\2\2\u071a\u071c\t"+ 16410 "\2\2\2\u071b\u071a\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2\2\2\u071d"+ 16411 "\u071e\3\2\2\2\u071e\u075c\3\2\2\2\u071f\u071d\3\2\2\2\u0720\u0724\7\61"+ 16412 "\2\2\u0721\u0723\t\2\2\2\u0722\u0721\3\2\2\2\u0723\u0726\3\2\2\2\u0724"+ 16413 "\u0722\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u075c\3\2\2\2\u0726\u0724\3\2"+ 16414 "\2\2\u0727\u072b\7\62\2\2\u0728\u072a\t\2\2\2\u0729\u0728\3\2\2\2\u072a"+ 16415 "\u072d\3\2\2\2\u072b\u0729\3\2\2\2\u072b\u072c\3\2\2\2\u072c\u072e\3\2"+ 16416 "\2\2\u072d\u072b\3\2\2\2\u072e\u0730\5\u008cG\2\u072f\u0731\5\u008aF\2"+ 16417 "\u0730\u072f\3\2\2\2\u0730\u0731\3\2\2\2\u0731\u075c\3\2\2\2\u0732\u0736"+ 16418 "\7\63\2\2\u0733\u0735\t\2\2\2\u0734\u0733\3\2\2\2\u0735\u0738\3\2\2\2"+ 16419 "\u0736\u0734\3\2\2\2\u0736\u0737\3\2\2\2\u0737\u0739\3\2\2\2\u0738\u0736"+ 16420 "\3\2\2\2\u0739\u073b\5\u008cG\2\u073a\u073c\5\u008aF\2\u073b\u073a\3\2"+ 16421 "\2\2\u073b\u073c\3\2\2\2\u073c\u075c\3\2\2\2\u073d\u0744\7\64\2\2\u073e"+ 16422 "\u0743\7\6\2\2\u073f\u0743\7\b\2\2\u0740\u0743\7\3\2\2\u0741\u0743\5\u0096"+ 16423 "L\2\u0742\u073e\3\2\2\2\u0742\u073f\3\2\2\2\u0742\u0740\3\2\2\2\u0742"+ 16424 "\u0741\3\2\2\2\u0743\u0746\3\2\2\2\u0744\u0742\3\2\2\2\u0744\u0745\3\2"+ 16425 "\2\2\u0745\u075c\3\2\2\2\u0746\u0744\3\2\2\2\u0747\u074b\7\65\2\2\u0748"+ 16426 "\u074a\t\2\2\2\u0749\u0748\3\2\2\2\u074a\u074d\3\2\2\2\u074b\u0749\3\2"+ 16427 "\2\2\u074b\u074c\3\2\2\2\u074c\u074f\3\2\2\2\u074d\u074b\3\2\2\2\u074e"+ 16428 "\u0750\5\u008cG\2\u074f\u074e\3\2\2\2\u074f\u0750\3\2\2\2\u0750\u075c"+ 16429 "\3\2\2\2\u0751\u0755\7\27\2\2\u0752\u0754\t\2\2\2\u0753\u0752\3\2\2\2"+ 16430 "\u0754\u0757\3\2\2\2\u0755\u0753\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0759"+ 16431 "\3\2\2\2\u0757\u0755\3\2\2\2\u0758\u075a\5\u008aF\2\u0759\u0758\3\2\2"+ 16432 "\2\u0759\u075a\3\2\2\2\u075a\u075c\3\2\2\2\u075b\u070f\3\2\2\2\u075b\u0719"+ 16433 "\3\2\2\2\u075b\u0720\3\2\2\2\u075b\u0727\3\2\2\2\u075b\u0732\3\2\2\2\u075b"+ 16434 "\u073d\3\2\2\2\u075b\u0747\3\2\2\2\u075b\u0751\3\2\2\2\u075c\u075d\3\2"+ 16435 "\2\2\u075d\u075e\7\26\2\2\u075e\u0093\3\2\2\2\u075f\u0765\7\4\2\2\u0760"+ 16436 "\u0764\5\u0096L\2\u0761\u0764\7\b\2\2\u0762\u0764\7\3\2\2\u0763\u0760"+ 16437 "\3\2\2\2\u0763\u0761\3\2\2\2\u0763\u0762\3\2\2\2\u0764\u0767\3\2\2\2\u0765"+ 16438 "\u0763\3\2\2\2\u0765\u0766\3\2\2\2\u0766\u0768\3\2\2\2\u0767\u0765\3\2"+ 16439 "\2\2\u0768\u0769\7]\2\2\u0769\u0095\3\2\2\2\u076a\u076b\t\n\2\2\u076b"+ 16440 "\u076d\bL\1\2\u076c\u076a\3\2\2\2\u076d\u076e\3\2\2\2\u076e\u076c\3\2"+ 16441 "\2\2\u076e\u076f\3\2\2\2\u076f\u0097\3\2\2\2\u00c5\u00a0\u00a2\u00a6\u00ab"+ 16442 "\u00b1\u00e5\u00ed\u00ef\u00fa\u0103\u010a\u0110\u011b\u011d\u012b\u012d"+ 16443 "\u0132\u013a\u013c\u0147\u0172\u0174\u017f\u0181\u018c\u01b7\u01b9\u01c4"+ 16444 "\u01c6\u01d1\u01fc\u01fe\u0209\u020b\u0216\u0241\u0243\u024e\u0250\u025b"+ 16445 "\u0286\u0288\u0293\u0295\u02a0\u02cb\u02cd\u02d8\u02da\u02e5\u0310\u0312"+ 16446 "\u031d\u031f\u032a\u0355\u0357\u0362\u0364\u036f\u039a\u039c\u03a7\u03a9"+ 16447 "\u03b4\u03df\u03e1\u03ec\u03ee\u03f9\u0424\u0426\u0431\u0433\u043e\u0469"+ 16448 "\u046b\u0476\u0478\u0483\u04ae\u04b0\u04bb\u04bd\u04c8\u04f3\u04f5\u0500"+ 16449 "\u0502\u050d\u0538\u053a\u054e\u0556\u0558\u0563\u0565\u0570\u0572\u057d"+ 16450 "\u057f\u058a\u058c\u0597\u0599\u05a4\u05a6\u05b1\u05b3\u05be\u05c0\u05cb"+ 16451 "\u05cd\u05d8\u05da\u05e5\u05e7\u05f2\u05f4\u05ff\u0601\u0616\u0618\u061e"+ 16452 "\u0622\u0625\u0628\u062d\u0630\u0633\u0636\u0639\u063d\u063f\u0645\u064e"+ 16453 "\u0652\u0658\u065c\u0662\u0666\u066b\u066f\u0675\u0679\u067e\u0682\u0688"+ 16454 "\u068c\u0692\u0696\u069a\u069c\u06a2\u06a6\u06ac\u06b0\u06b3\u06b9\u06bd"+ 16455 "\u06c3\u06c7\u06cc\u06d0\u06d5\u06d9\u06df\u06e3\u06e9\u06ed\u06f2\u06f6"+ 16456 "\u06fc\u0700\u0706\u070a\u070c\u0714\u0716\u071d\u0724\u072b\u0730\u0736"+ 16457 "\u073b\u0742\u0744\u074b\u074f\u0755\u0759\u075b\u0763\u0765\u076e"; 16458 public static final ATN _ATN = 16459 new ATNDeserializer().deserialize(_serializedATN.toCharArray()); 16460 static { 16461 _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; 16462 for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { 16463 _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); 16464 } 16465 } 16466}