Created
April 18, 2022 15:22
-
-
Save pbludov/3bac5ebbdce6c2ab1eab083a87d9adf6 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| // Generated from com/puppycrawl/tools/checkstyle/grammar/javadoc/JavadocParser.g4 by ANTLR 4.10.1 | |
| package com.puppycrawl.tools.checkstyle.grammar.javadoc; | |
| import org.antlr.v4.runtime.atn.*; | |
| import org.antlr.v4.runtime.dfa.DFA; | |
| import org.antlr.v4.runtime.*; | |
| import org.antlr.v4.runtime.misc.*; | |
| import org.antlr.v4.runtime.tree.*; | |
| import java.util.List; | |
| import java.util.Iterator; | |
| import java.util.ArrayList; | |
| @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) | |
| public class JavadocParser extends Parser { | |
| static { RuntimeMetaData.checkVersion("4.10.1", RuntimeMetaData.VERSION); } | |
| protected static final DFA[] _decisionToDFA; | |
| protected static final PredictionContextCache _sharedContextCache = | |
| new PredictionContextCache(); | |
| public static final int | |
| LEADING_ASTERISK=1, HTML_COMMENT_START=2, DEPRECATED_CDATA_DO_NOT_USE=3, | |
| WS=4, START=5, NEWLINE=6, AUTHOR_LITERAL=7, DEPRECATED_LITERAL=8, EXCEPTION_LITERAL=9, | |
| PARAM_LITERAL=10, RETURN_LITERAL=11, SEE_LITERAL=12, SERIAL_LITERAL=13, | |
| SERIAL_FIELD_LITERAL=14, SERIAL_DATA_LITERAL=15, SINCE_LITERAL=16, THROWS_LITERAL=17, | |
| VERSION_LITERAL=18, JAVADOC_INLINE_TAG_START=19, JAVADOC_INLINE_TAG_END=20, | |
| CUSTOM_NAME=21, LITERAL_INCLUDE=22, LITERAL_EXCLUDE=23, CHAR=24, PARAMETER_NAME=25, | |
| Char1=26, STRING=27, PACKAGE_CLASS=28, DOT=29, HASH=30, CLASS=31, Char2=32, | |
| MEMBER=33, LEFT_BRACE=34, RIGHT_BRACE=35, ARGUMENT=36, COMMA=37, Char20=38, | |
| FIELD_NAME=39, Char3=40, FIELD_TYPE=41, Char4=42, CLASS_NAME=43, Char5=44, | |
| CODE_LITERAL=45, DOC_ROOT_LITERAL=46, INHERIT_DOC_LITERAL=47, LINK_LITERAL=48, | |
| LINKPLAIN_LITERAL=49, LITERAL_LITERAL=50, VALUE_LITERAL=51, Char7=52, | |
| Char8=53, Char10=54, END=55, SLASH_END=56, SLASH=57, EQUALS=58, P_HTML_TAG_NAME=59, | |
| LI_HTML_TAG_NAME=60, TR_HTML_TAG_NAME=61, TD_HTML_TAG_NAME=62, TH_HTML_TAG_NAME=63, | |
| BODY_HTML_TAG_NAME=64, COLGROUP_HTML_TAG_NAME=65, DD_HTML_TAG_NAME=66, | |
| DT_HTML_TAG_NAME=67, HEAD_HTML_TAG_NAME=68, HTML_HTML_TAG_NAME=69, OPTION_HTML_TAG_NAME=70, | |
| TBODY_HTML_TAG_NAME=71, TFOOT_HTML_TAG_NAME=72, THEAD_HTML_TAG_NAME=73, | |
| AREA_HTML_TAG_NAME=74, BASE_HTML_TAG_NAME=75, BASEFONT_HTML_TAG_NAME=76, | |
| BR_HTML_TAG_NAME=77, COL_HTML_TAG_NAME=78, FRAME_HTML_TAG_NAME=79, HR_HTML_TAG_NAME=80, | |
| IMG_HTML_TAG_NAME=81, INPUT_HTML_TAG_NAME=82, ISINDEX_HTML_TAG_NAME=83, | |
| LINK_HTML_TAG_NAME=84, META_HTML_TAG_NAME=85, PARAM_HTML_TAG_NAME=86, | |
| EMBED_HTML_TAG_NAME=87, KEYGEN_HTML_TAG_NAME=88, ATTR_VALUE=89, Char12=90, | |
| HTML_COMMENT_END=91, SOURCE_HTML_TAG_NAME=92, TRACK_HTML_TAG_NAME=93, | |
| WBR_HTML_TAG_NAME=94, OPTGROUP_HTML_TAG_NAME=95, RB_HTML_TAG_NAME=96, | |
| RT_HTML_TAG_NAME=97, RTC_HTML_TAG_NAME=98, RP_HTML_TAG_NAME=99, HTML_TAG_NAME=100, | |
| Char11=101; | |
| public static final int | |
| RULE_javadoc = 0, RULE_htmlElement = 1, RULE_htmlElementStart = 2, RULE_htmlElementEnd = 3, | |
| RULE_attribute = 4, RULE_htmlTag = 5, RULE_pTagStart = 6, RULE_pTagEnd = 7, | |
| RULE_paragraph = 8, RULE_liTagStart = 9, RULE_liTagEnd = 10, RULE_li = 11, | |
| RULE_trTagStart = 12, RULE_trTagEnd = 13, RULE_tr = 14, RULE_tdTagStart = 15, | |
| RULE_tdTagEnd = 16, RULE_td = 17, RULE_thTagStart = 18, RULE_thTagEnd = 19, | |
| RULE_th = 20, RULE_bodyTagStart = 21, RULE_bodyTagEnd = 22, RULE_body = 23, | |
| RULE_colgroupTagStart = 24, RULE_colgroupTagEnd = 25, RULE_colgroup = 26, | |
| RULE_ddTagStart = 27, RULE_ddTagEnd = 28, RULE_dd = 29, RULE_dtTagStart = 30, | |
| RULE_dtTagEnd = 31, RULE_dt = 32, RULE_headTagStart = 33, RULE_headTagEnd = 34, | |
| RULE_head = 35, RULE_htmlTagStart = 36, RULE_htmlTagEnd = 37, RULE_html = 38, | |
| RULE_optionTagStart = 39, RULE_optionTagEnd = 40, RULE_option = 41, RULE_tbodyTagStart = 42, | |
| RULE_tbodyTagEnd = 43, RULE_tbody = 44, RULE_tfootTagStart = 45, RULE_tfootTagEnd = 46, | |
| RULE_tfoot = 47, RULE_theadTagStart = 48, RULE_theadTagEnd = 49, RULE_thead = 50, | |
| RULE_singletonElement = 51, RULE_emptyTag = 52, RULE_areaTag = 53, RULE_baseTag = 54, | |
| RULE_basefontTag = 55, RULE_brTag = 56, RULE_colTag = 57, RULE_frameTag = 58, | |
| RULE_hrTag = 59, RULE_imgTag = 60, RULE_inputTag = 61, RULE_isindexTag = 62, | |
| RULE_linkTag = 63, RULE_metaTag = 64, RULE_paramTag = 65, RULE_wrongSingletonTag = 66, | |
| RULE_singletonTagName = 67, RULE_description = 68, RULE_reference = 69, | |
| RULE_parameters = 70, RULE_javadocTag = 71, RULE_javadocInlineTag = 72, | |
| RULE_htmlComment = 73, RULE_text = 74, RULE_embedTag = 75, RULE_keygenTag = 76, | |
| RULE_sourceTag = 77, RULE_trackTag = 78, RULE_wbrTag = 79, RULE_optgroupTagStart = 80, | |
| RULE_optgroupTagEnd = 81, RULE_optgroup = 82, RULE_rbTagStart = 83, RULE_rbTagEnd = 84, | |
| RULE_rb = 85, RULE_rtTagStart = 86, RULE_rtTagEnd = 87, RULE_rt = 88, | |
| RULE_rtcTagStart = 89, RULE_rtcTagEnd = 90, RULE_rtc = 91, RULE_rpTagStart = 92, | |
| RULE_rpTagEnd = 93, RULE_rp = 94; | |
| private static String[] makeRuleNames() { | |
| return new String[] { | |
| "javadoc", "htmlElement", "htmlElementStart", "htmlElementEnd", "attribute", | |
| "htmlTag", "pTagStart", "pTagEnd", "paragraph", "liTagStart", "liTagEnd", | |
| "li", "trTagStart", "trTagEnd", "tr", "tdTagStart", "tdTagEnd", "td", | |
| "thTagStart", "thTagEnd", "th", "bodyTagStart", "bodyTagEnd", "body", | |
| "colgroupTagStart", "colgroupTagEnd", "colgroup", "ddTagStart", "ddTagEnd", | |
| "dd", "dtTagStart", "dtTagEnd", "dt", "headTagStart", "headTagEnd", "head", | |
| "htmlTagStart", "htmlTagEnd", "html", "optionTagStart", "optionTagEnd", | |
| "option", "tbodyTagStart", "tbodyTagEnd", "tbody", "tfootTagStart", "tfootTagEnd", | |
| "tfoot", "theadTagStart", "theadTagEnd", "thead", "singletonElement", | |
| "emptyTag", "areaTag", "baseTag", "basefontTag", "brTag", "colTag", "frameTag", | |
| "hrTag", "imgTag", "inputTag", "isindexTag", "linkTag", "metaTag", "paramTag", | |
| "wrongSingletonTag", "singletonTagName", "description", "reference", | |
| "parameters", "javadocTag", "javadocInlineTag", "htmlComment", "text", | |
| "embedTag", "keygenTag", "sourceTag", "trackTag", "wbrTag", "optgroupTagStart", | |
| "optgroupTagEnd", "optgroup", "rbTagStart", "rbTagEnd", "rb", "rtTagStart", | |
| "rtTagEnd", "rt", "rtcTagStart", "rtcTagEnd", "rtc", "rpTagStart", "rpTagEnd", | |
| "rp" | |
| }; | |
| } | |
| public static final String[] ruleNames = makeRuleNames(); | |
| private static String[] makeLiteralNames() { | |
| return new String[] { | |
| null, null, null, null, null, null, null, "'@author'", "'@deprecated'", | |
| null, null, "'@return'", null, "'@serial'", null, "'@serialData'", "'@since'", | |
| null, "'@version'", null, null, null, "'include'", "'exclude'", null, | |
| null, null, null, null, "'.'", null, null, null, null, "'('", "')'", | |
| null, "','", null, null, null, null, null, null, null, null, "'@docRoot'", | |
| "'@inheritDoc'", "'@link'", "'@linkplain'", null, "'@value'", null, null, | |
| null, null, null, "'/'", "'='", null, null, null, null, null, null, null, | |
| null, null, null, null, null, null, null, null, null, null, null, null, | |
| null, null, null, null, null, null, null, null, null, null, null, null, | |
| null, "'-->'" | |
| }; | |
| } | |
| private static final String[] _LITERAL_NAMES = makeLiteralNames(); | |
| private static String[] makeSymbolicNames() { | |
| return new String[] { | |
| null, "LEADING_ASTERISK", "HTML_COMMENT_START", "DEPRECATED_CDATA_DO_NOT_USE", | |
| "WS", "START", "NEWLINE", "AUTHOR_LITERAL", "DEPRECATED_LITERAL", "EXCEPTION_LITERAL", | |
| "PARAM_LITERAL", "RETURN_LITERAL", "SEE_LITERAL", "SERIAL_LITERAL", "SERIAL_FIELD_LITERAL", | |
| "SERIAL_DATA_LITERAL", "SINCE_LITERAL", "THROWS_LITERAL", "VERSION_LITERAL", | |
| "JAVADOC_INLINE_TAG_START", "JAVADOC_INLINE_TAG_END", "CUSTOM_NAME", | |
| "LITERAL_INCLUDE", "LITERAL_EXCLUDE", "CHAR", "PARAMETER_NAME", "Char1", | |
| "STRING", "PACKAGE_CLASS", "DOT", "HASH", "CLASS", "Char2", "MEMBER", | |
| "LEFT_BRACE", "RIGHT_BRACE", "ARGUMENT", "COMMA", "Char20", "FIELD_NAME", | |
| "Char3", "FIELD_TYPE", "Char4", "CLASS_NAME", "Char5", "CODE_LITERAL", | |
| "DOC_ROOT_LITERAL", "INHERIT_DOC_LITERAL", "LINK_LITERAL", "LINKPLAIN_LITERAL", | |
| "LITERAL_LITERAL", "VALUE_LITERAL", "Char7", "Char8", "Char10", "END", | |
| "SLASH_END", "SLASH", "EQUALS", "P_HTML_TAG_NAME", "LI_HTML_TAG_NAME", | |
| "TR_HTML_TAG_NAME", "TD_HTML_TAG_NAME", "TH_HTML_TAG_NAME", "BODY_HTML_TAG_NAME", | |
| "COLGROUP_HTML_TAG_NAME", "DD_HTML_TAG_NAME", "DT_HTML_TAG_NAME", "HEAD_HTML_TAG_NAME", | |
| "HTML_HTML_TAG_NAME", "OPTION_HTML_TAG_NAME", "TBODY_HTML_TAG_NAME", | |
| "TFOOT_HTML_TAG_NAME", "THEAD_HTML_TAG_NAME", "AREA_HTML_TAG_NAME", "BASE_HTML_TAG_NAME", | |
| "BASEFONT_HTML_TAG_NAME", "BR_HTML_TAG_NAME", "COL_HTML_TAG_NAME", "FRAME_HTML_TAG_NAME", | |
| "HR_HTML_TAG_NAME", "IMG_HTML_TAG_NAME", "INPUT_HTML_TAG_NAME", "ISINDEX_HTML_TAG_NAME", | |
| "LINK_HTML_TAG_NAME", "META_HTML_TAG_NAME", "PARAM_HTML_TAG_NAME", "EMBED_HTML_TAG_NAME", | |
| "KEYGEN_HTML_TAG_NAME", "ATTR_VALUE", "Char12", "HTML_COMMENT_END", "SOURCE_HTML_TAG_NAME", | |
| "TRACK_HTML_TAG_NAME", "WBR_HTML_TAG_NAME", "OPTGROUP_HTML_TAG_NAME", | |
| "RB_HTML_TAG_NAME", "RT_HTML_TAG_NAME", "RTC_HTML_TAG_NAME", "RP_HTML_TAG_NAME", | |
| "HTML_TAG_NAME", "Char11" | |
| }; | |
| } | |
| private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); | |
| public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); | |
| /** | |
| * @deprecated Use {@link #VOCABULARY} instead. | |
| */ | |
| @Deprecated | |
| public static final String[] tokenNames; | |
| static { | |
| tokenNames = new String[_SYMBOLIC_NAMES.length]; | |
| for (int i = 0; i < tokenNames.length; i++) { | |
| tokenNames[i] = VOCABULARY.getLiteralName(i); | |
| if (tokenNames[i] == null) { | |
| tokenNames[i] = VOCABULARY.getSymbolicName(i); | |
| } | |
| if (tokenNames[i] == null) { | |
| tokenNames[i] = "<INVALID>"; | |
| } | |
| } | |
| } | |
| @Override | |
| @Deprecated | |
| public String[] getTokenNames() { | |
| return tokenNames; | |
| } | |
| @Override | |
| public Vocabulary getVocabulary() { | |
| return VOCABULARY; | |
| } | |
| @Override | |
| public String getGrammarFileName() { return "JavadocParser.g4"; } | |
| @Override | |
| public String[] getRuleNames() { return ruleNames; } | |
| @Override | |
| public String getSerializedATN() { return _serializedATN; } | |
| @Override | |
| public ATN getATN() { return _ATN; } | |
| boolean isNextJavadocTag() { | |
| int token1 = _input.LA(2); | |
| int token2 = _input.LA(3); | |
| return isJavadocTag(token1) | |
| || (token1 == WS && isJavadocTag(token2)); | |
| } | |
| boolean isJavadocTag(int type) { | |
| switch(type) { | |
| case AUTHOR_LITERAL: | |
| case DEPRECATED_LITERAL: | |
| case EXCEPTION_LITERAL: | |
| case PARAM_LITERAL: | |
| case RETURN_LITERAL: | |
| case SEE_LITERAL: | |
| case SERIAL_LITERAL: | |
| case SERIAL_FIELD_LITERAL: | |
| case SERIAL_DATA_LITERAL: | |
| case SINCE_LITERAL: | |
| case THROWS_LITERAL: | |
| case VERSION_LITERAL: | |
| case CUSTOM_NAME: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| boolean isSameTagNames(ParserRuleContext htmlTagStart, ParserRuleContext htmlTagEnd) { | |
| String startTag = htmlTagStart.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); | |
| String endTag = htmlTagEnd.getToken(HTML_TAG_NAME, 0).getText().toLowerCase(); | |
| return startTag.equals(endTag); | |
| } | |
| public ParserRuleContext nonTightTagStartContext; | |
| public JavadocParser(TokenStream input) { | |
| super(input); | |
| _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); | |
| } | |
| public static class JavadocContext extends ParserRuleContext { | |
| public TerminalNode EOF() { return getToken(JavadocParser.EOF, 0); } | |
| public List<HtmlElementContext> htmlElement() { | |
| return getRuleContexts(HtmlElementContext.class); | |
| } | |
| public HtmlElementContext htmlElement(int i) { | |
| return getRuleContext(HtmlElementContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<JavadocTagContext> javadocTag() { | |
| return getRuleContexts(JavadocTagContext.class); | |
| } | |
| public JavadocTagContext javadocTag(int i) { | |
| return getRuleContext(JavadocTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public JavadocContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_javadoc; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadoc(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final JavadocContext javadoc() throws RecognitionException { | |
| JavadocContext _localctx = new JavadocContext(_ctx, getState()); | |
| enterRule(_localctx, 0, RULE_javadoc); | |
| int _la; | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(199); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,1,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(197); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { | |
| case 1: | |
| { | |
| setState(190); | |
| htmlElement(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| { | |
| setState(191); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(192); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(193); | |
| htmlComment(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(194); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(195); | |
| text(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(196); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(201); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,1,_ctx); | |
| } | |
| setState(214); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| 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)) { | |
| { | |
| { | |
| setState(203); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| if (_la==LEADING_ASTERISK) { | |
| { | |
| setState(202); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| setState(208); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while (_la==WS) { | |
| { | |
| { | |
| setState(205); | |
| match(WS); | |
| } | |
| } | |
| setState(210); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(211); | |
| javadocTag(); | |
| } | |
| } | |
| setState(216); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(217); | |
| match(EOF); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class HtmlElementContext extends ParserRuleContext { | |
| public HtmlTagContext htmlTag() { | |
| return getRuleContext(HtmlTagContext.class,0); | |
| } | |
| public SingletonElementContext singletonElement() { | |
| return getRuleContext(SingletonElementContext.class,0); | |
| } | |
| public ParagraphContext paragraph() { | |
| return getRuleContext(ParagraphContext.class,0); | |
| } | |
| public LiContext li() { | |
| return getRuleContext(LiContext.class,0); | |
| } | |
| public TrContext tr() { | |
| return getRuleContext(TrContext.class,0); | |
| } | |
| public TdContext td() { | |
| return getRuleContext(TdContext.class,0); | |
| } | |
| public ThContext th() { | |
| return getRuleContext(ThContext.class,0); | |
| } | |
| public BodyContext body() { | |
| return getRuleContext(BodyContext.class,0); | |
| } | |
| public ColgroupContext colgroup() { | |
| return getRuleContext(ColgroupContext.class,0); | |
| } | |
| public DdContext dd() { | |
| return getRuleContext(DdContext.class,0); | |
| } | |
| public DtContext dt() { | |
| return getRuleContext(DtContext.class,0); | |
| } | |
| public HeadContext head() { | |
| return getRuleContext(HeadContext.class,0); | |
| } | |
| public HtmlContext html() { | |
| return getRuleContext(HtmlContext.class,0); | |
| } | |
| public OptionContext option() { | |
| return getRuleContext(OptionContext.class,0); | |
| } | |
| public TbodyContext tbody() { | |
| return getRuleContext(TbodyContext.class,0); | |
| } | |
| public TheadContext thead() { | |
| return getRuleContext(TheadContext.class,0); | |
| } | |
| public TfootContext tfoot() { | |
| return getRuleContext(TfootContext.class,0); | |
| } | |
| public OptgroupContext optgroup() { | |
| return getRuleContext(OptgroupContext.class,0); | |
| } | |
| public RbContext rb() { | |
| return getRuleContext(RbContext.class,0); | |
| } | |
| public RtContext rt() { | |
| return getRuleContext(RtContext.class,0); | |
| } | |
| public RtcContext rtc() { | |
| return getRuleContext(RtcContext.class,0); | |
| } | |
| public RpContext rp() { | |
| return getRuleContext(RpContext.class,0); | |
| } | |
| public PTagStartContext pTagStart() { | |
| return getRuleContext(PTagStartContext.class,0); | |
| } | |
| public LiTagStartContext liTagStart() { | |
| return getRuleContext(LiTagStartContext.class,0); | |
| } | |
| public TrTagStartContext trTagStart() { | |
| return getRuleContext(TrTagStartContext.class,0); | |
| } | |
| public TdTagStartContext tdTagStart() { | |
| return getRuleContext(TdTagStartContext.class,0); | |
| } | |
| public ThTagStartContext thTagStart() { | |
| return getRuleContext(ThTagStartContext.class,0); | |
| } | |
| public BodyTagStartContext bodyTagStart() { | |
| return getRuleContext(BodyTagStartContext.class,0); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart() { | |
| return getRuleContext(ColgroupTagStartContext.class,0); | |
| } | |
| public DdTagStartContext ddTagStart() { | |
| return getRuleContext(DdTagStartContext.class,0); | |
| } | |
| public DtTagStartContext dtTagStart() { | |
| return getRuleContext(DtTagStartContext.class,0); | |
| } | |
| public HeadTagStartContext headTagStart() { | |
| return getRuleContext(HeadTagStartContext.class,0); | |
| } | |
| public HtmlTagStartContext htmlTagStart() { | |
| return getRuleContext(HtmlTagStartContext.class,0); | |
| } | |
| public OptionTagStartContext optionTagStart() { | |
| return getRuleContext(OptionTagStartContext.class,0); | |
| } | |
| public TbodyTagStartContext tbodyTagStart() { | |
| return getRuleContext(TbodyTagStartContext.class,0); | |
| } | |
| public TheadTagStartContext theadTagStart() { | |
| return getRuleContext(TheadTagStartContext.class,0); | |
| } | |
| public TfootTagStartContext tfootTagStart() { | |
| return getRuleContext(TfootTagStartContext.class,0); | |
| } | |
| public OptgroupTagStartContext optgroupTagStart() { | |
| return getRuleContext(OptgroupTagStartContext.class,0); | |
| } | |
| public RbTagStartContext rbTagStart() { | |
| return getRuleContext(RbTagStartContext.class,0); | |
| } | |
| public RtTagStartContext rtTagStart() { | |
| return getRuleContext(RtTagStartContext.class,0); | |
| } | |
| public RtcTagStartContext rtcTagStart() { | |
| return getRuleContext(RtcTagStartContext.class,0); | |
| } | |
| public RpTagStartContext rpTagStart() { | |
| return getRuleContext(RpTagStartContext.class,0); | |
| } | |
| public PTagEndContext pTagEnd() { | |
| return getRuleContext(PTagEndContext.class,0); | |
| } | |
| public LiTagEndContext liTagEnd() { | |
| return getRuleContext(LiTagEndContext.class,0); | |
| } | |
| public TrTagEndContext trTagEnd() { | |
| return getRuleContext(TrTagEndContext.class,0); | |
| } | |
| public TdTagEndContext tdTagEnd() { | |
| return getRuleContext(TdTagEndContext.class,0); | |
| } | |
| public ThTagEndContext thTagEnd() { | |
| return getRuleContext(ThTagEndContext.class,0); | |
| } | |
| public BodyTagEndContext bodyTagEnd() { | |
| return getRuleContext(BodyTagEndContext.class,0); | |
| } | |
| public ColgroupTagEndContext colgroupTagEnd() { | |
| return getRuleContext(ColgroupTagEndContext.class,0); | |
| } | |
| public DdTagEndContext ddTagEnd() { | |
| return getRuleContext(DdTagEndContext.class,0); | |
| } | |
| public DtTagEndContext dtTagEnd() { | |
| return getRuleContext(DtTagEndContext.class,0); | |
| } | |
| public HeadTagEndContext headTagEnd() { | |
| return getRuleContext(HeadTagEndContext.class,0); | |
| } | |
| public HtmlTagEndContext htmlTagEnd() { | |
| return getRuleContext(HtmlTagEndContext.class,0); | |
| } | |
| public OptionTagEndContext optionTagEnd() { | |
| return getRuleContext(OptionTagEndContext.class,0); | |
| } | |
| public TbodyTagEndContext tbodyTagEnd() { | |
| return getRuleContext(TbodyTagEndContext.class,0); | |
| } | |
| public TheadTagEndContext theadTagEnd() { | |
| return getRuleContext(TheadTagEndContext.class,0); | |
| } | |
| public TfootTagEndContext tfootTagEnd() { | |
| return getRuleContext(TfootTagEndContext.class,0); | |
| } | |
| public OptgroupTagEndContext optgroupTagEnd() { | |
| return getRuleContext(OptgroupTagEndContext.class,0); | |
| } | |
| public RbTagEndContext rbTagEnd() { | |
| return getRuleContext(RbTagEndContext.class,0); | |
| } | |
| public RtTagEndContext rtTagEnd() { | |
| return getRuleContext(RtTagEndContext.class,0); | |
| } | |
| public RtcTagEndContext rtcTagEnd() { | |
| return getRuleContext(RtcTagEndContext.class,0); | |
| } | |
| public RpTagEndContext rpTagEnd() { | |
| return getRuleContext(RpTagEndContext.class,0); | |
| } | |
| public HtmlElementContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_htmlElement; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElement(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final HtmlElementContext htmlElement() throws RecognitionException { | |
| HtmlElementContext _localctx = new HtmlElementContext(_ctx, getState()); | |
| enterRule(_localctx, 2, RULE_htmlElement); | |
| try { | |
| setState(281); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { | |
| case 1: | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(219); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| enterOuterAlt(_localctx, 2); | |
| { | |
| setState(220); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| enterOuterAlt(_localctx, 3); | |
| { | |
| setState(221); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| enterOuterAlt(_localctx, 4); | |
| { | |
| setState(222); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| enterOuterAlt(_localctx, 5); | |
| { | |
| setState(223); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| enterOuterAlt(_localctx, 6); | |
| { | |
| setState(224); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| enterOuterAlt(_localctx, 7); | |
| { | |
| setState(225); | |
| th(); | |
| } | |
| break; | |
| case 8: | |
| enterOuterAlt(_localctx, 8); | |
| { | |
| setState(226); | |
| body(); | |
| } | |
| break; | |
| case 9: | |
| enterOuterAlt(_localctx, 9); | |
| { | |
| setState(227); | |
| colgroup(); | |
| } | |
| break; | |
| case 10: | |
| enterOuterAlt(_localctx, 10); | |
| { | |
| setState(228); | |
| dd(); | |
| } | |
| break; | |
| case 11: | |
| enterOuterAlt(_localctx, 11); | |
| { | |
| setState(229); | |
| dt(); | |
| } | |
| break; | |
| case 12: | |
| enterOuterAlt(_localctx, 12); | |
| { | |
| setState(230); | |
| head(); | |
| } | |
| break; | |
| case 13: | |
| enterOuterAlt(_localctx, 13); | |
| { | |
| setState(231); | |
| html(); | |
| } | |
| break; | |
| case 14: | |
| enterOuterAlt(_localctx, 14); | |
| { | |
| setState(232); | |
| option(); | |
| } | |
| break; | |
| case 15: | |
| enterOuterAlt(_localctx, 15); | |
| { | |
| setState(233); | |
| tbody(); | |
| } | |
| break; | |
| case 16: | |
| enterOuterAlt(_localctx, 16); | |
| { | |
| setState(234); | |
| thead(); | |
| } | |
| break; | |
| case 17: | |
| enterOuterAlt(_localctx, 17); | |
| { | |
| setState(235); | |
| tfoot(); | |
| } | |
| break; | |
| case 18: | |
| enterOuterAlt(_localctx, 18); | |
| { | |
| setState(236); | |
| optgroup(); | |
| } | |
| break; | |
| case 19: | |
| enterOuterAlt(_localctx, 19); | |
| { | |
| setState(237); | |
| rb(); | |
| } | |
| break; | |
| case 20: | |
| enterOuterAlt(_localctx, 20); | |
| { | |
| setState(238); | |
| rt(); | |
| } | |
| break; | |
| case 21: | |
| enterOuterAlt(_localctx, 21); | |
| { | |
| setState(239); | |
| rtc(); | |
| } | |
| break; | |
| case 22: | |
| enterOuterAlt(_localctx, 22); | |
| { | |
| setState(240); | |
| rp(); | |
| } | |
| break; | |
| case 23: | |
| enterOuterAlt(_localctx, 23); | |
| { | |
| setState(241); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| enterOuterAlt(_localctx, 24); | |
| { | |
| setState(242); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| enterOuterAlt(_localctx, 25); | |
| { | |
| setState(243); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| enterOuterAlt(_localctx, 26); | |
| { | |
| setState(244); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| enterOuterAlt(_localctx, 27); | |
| { | |
| setState(245); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| enterOuterAlt(_localctx, 28); | |
| { | |
| setState(246); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| enterOuterAlt(_localctx, 29); | |
| { | |
| setState(247); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| enterOuterAlt(_localctx, 30); | |
| { | |
| setState(248); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| enterOuterAlt(_localctx, 31); | |
| { | |
| setState(249); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 32: | |
| enterOuterAlt(_localctx, 32); | |
| { | |
| setState(250); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 33: | |
| enterOuterAlt(_localctx, 33); | |
| { | |
| setState(251); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 34: | |
| enterOuterAlt(_localctx, 34); | |
| { | |
| setState(252); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 35: | |
| enterOuterAlt(_localctx, 35); | |
| { | |
| setState(253); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 36: | |
| enterOuterAlt(_localctx, 36); | |
| { | |
| setState(254); | |
| theadTagStart(true); | |
| } | |
| break; | |
| case 37: | |
| enterOuterAlt(_localctx, 37); | |
| { | |
| setState(255); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 38: | |
| enterOuterAlt(_localctx, 38); | |
| { | |
| setState(256); | |
| optgroupTagStart(true); | |
| } | |
| break; | |
| case 39: | |
| enterOuterAlt(_localctx, 39); | |
| { | |
| setState(257); | |
| rbTagStart(true); | |
| } | |
| break; | |
| case 40: | |
| enterOuterAlt(_localctx, 40); | |
| { | |
| setState(258); | |
| rtTagStart(true); | |
| } | |
| break; | |
| case 41: | |
| enterOuterAlt(_localctx, 41); | |
| { | |
| setState(259); | |
| rtcTagStart(true); | |
| } | |
| break; | |
| case 42: | |
| enterOuterAlt(_localctx, 42); | |
| { | |
| setState(260); | |
| rpTagStart(true); | |
| } | |
| break; | |
| case 43: | |
| enterOuterAlt(_localctx, 43); | |
| { | |
| setState(261); | |
| pTagEnd(); | |
| } | |
| break; | |
| case 44: | |
| enterOuterAlt(_localctx, 44); | |
| { | |
| setState(262); | |
| liTagEnd(); | |
| } | |
| break; | |
| case 45: | |
| enterOuterAlt(_localctx, 45); | |
| { | |
| setState(263); | |
| trTagEnd(); | |
| } | |
| break; | |
| case 46: | |
| enterOuterAlt(_localctx, 46); | |
| { | |
| setState(264); | |
| tdTagEnd(); | |
| } | |
| break; | |
| case 47: | |
| enterOuterAlt(_localctx, 47); | |
| { | |
| setState(265); | |
| thTagEnd(); | |
| } | |
| break; | |
| case 48: | |
| enterOuterAlt(_localctx, 48); | |
| { | |
| setState(266); | |
| bodyTagEnd(); | |
| } | |
| break; | |
| case 49: | |
| enterOuterAlt(_localctx, 49); | |
| { | |
| setState(267); | |
| colgroupTagEnd(); | |
| } | |
| break; | |
| case 50: | |
| enterOuterAlt(_localctx, 50); | |
| { | |
| setState(268); | |
| ddTagEnd(); | |
| } | |
| break; | |
| case 51: | |
| enterOuterAlt(_localctx, 51); | |
| { | |
| setState(269); | |
| dtTagEnd(); | |
| } | |
| break; | |
| case 52: | |
| enterOuterAlt(_localctx, 52); | |
| { | |
| setState(270); | |
| headTagEnd(); | |
| } | |
| break; | |
| case 53: | |
| enterOuterAlt(_localctx, 53); | |
| { | |
| setState(271); | |
| htmlTagEnd(); | |
| } | |
| break; | |
| case 54: | |
| enterOuterAlt(_localctx, 54); | |
| { | |
| setState(272); | |
| optionTagEnd(); | |
| } | |
| break; | |
| case 55: | |
| enterOuterAlt(_localctx, 55); | |
| { | |
| setState(273); | |
| tbodyTagEnd(); | |
| } | |
| break; | |
| case 56: | |
| enterOuterAlt(_localctx, 56); | |
| { | |
| setState(274); | |
| theadTagEnd(); | |
| } | |
| break; | |
| case 57: | |
| enterOuterAlt(_localctx, 57); | |
| { | |
| setState(275); | |
| tfootTagEnd(); | |
| } | |
| break; | |
| case 58: | |
| enterOuterAlt(_localctx, 58); | |
| { | |
| setState(276); | |
| optgroupTagEnd(); | |
| } | |
| break; | |
| case 59: | |
| enterOuterAlt(_localctx, 59); | |
| { | |
| setState(277); | |
| rbTagEnd(); | |
| } | |
| break; | |
| case 60: | |
| enterOuterAlt(_localctx, 60); | |
| { | |
| setState(278); | |
| rtTagEnd(); | |
| } | |
| break; | |
| case 61: | |
| enterOuterAlt(_localctx, 61); | |
| { | |
| setState(279); | |
| rtcTagEnd(); | |
| } | |
| break; | |
| case 62: | |
| enterOuterAlt(_localctx, 62); | |
| { | |
| setState(280); | |
| rpTagEnd(); | |
| } | |
| break; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class HtmlElementStartContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public HtmlElementStartContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_htmlElementStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final HtmlElementStartContext htmlElementStart() throws RecognitionException { | |
| HtmlElementStartContext _localctx = new HtmlElementStartContext(_ctx, getState()); | |
| enterRule(_localctx, 4, RULE_htmlElementStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(283); | |
| match(START); | |
| setState(284); | |
| match(HTML_TAG_NAME); | |
| setState(291); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(289); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(285); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(286); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(287); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(288); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(293); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(294); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class HtmlElementEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public HtmlElementEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_htmlElementEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlElementEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final HtmlElementEndContext htmlElementEnd() throws RecognitionException { | |
| HtmlElementEndContext _localctx = new HtmlElementEndContext(_ctx, getState()); | |
| enterRule(_localctx, 6, RULE_htmlElementEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(296); | |
| match(START); | |
| setState(297); | |
| match(SLASH); | |
| setState(298); | |
| match(HTML_TAG_NAME); | |
| setState(302); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(299); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(304); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(305); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class AttributeContext extends ParserRuleContext { | |
| public List<TerminalNode> HTML_TAG_NAME() { return getTokens(JavadocParser.HTML_TAG_NAME); } | |
| public TerminalNode HTML_TAG_NAME(int i) { | |
| return getToken(JavadocParser.HTML_TAG_NAME, i); | |
| } | |
| public TerminalNode EQUALS() { return getToken(JavadocParser.EQUALS, 0); } | |
| public TerminalNode ATTR_VALUE() { return getToken(JavadocParser.ATTR_VALUE, 0); } | |
| public TextContext text() { | |
| return getRuleContext(TextContext.class,0); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public AttributeContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_attribute; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAttribute(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final AttributeContext attribute() throws RecognitionException { | |
| AttributeContext _localctx = new AttributeContext(_ctx, getState()); | |
| enterRule(_localctx, 8, RULE_attribute); | |
| int _la; | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(307); | |
| match(HTML_TAG_NAME); | |
| setState(311); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(308); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(313); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(314); | |
| match(EQUALS); | |
| setState(318); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,10,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(315); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(320); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,10,_ctx); | |
| } | |
| setState(324); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case ATTR_VALUE: | |
| { | |
| setState(321); | |
| match(ATTR_VALUE); | |
| } | |
| break; | |
| case WS: | |
| case CHAR: | |
| { | |
| setState(322); | |
| text(); | |
| } | |
| break; | |
| case HTML_TAG_NAME: | |
| { | |
| setState(323); | |
| match(HTML_TAG_NAME); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class HtmlTagContext extends ParserRuleContext { | |
| public HtmlElementStartContext htmlElementStart; | |
| public HtmlElementEndContext htmlElementEnd; | |
| public HtmlElementStartContext htmlElementStart() { | |
| return getRuleContext(HtmlElementStartContext.class,0); | |
| } | |
| public HtmlElementEndContext htmlElementEnd() { | |
| return getRuleContext(HtmlElementEndContext.class,0); | |
| } | |
| public List<HtmlElementContext> htmlElement() { | |
| return getRuleContexts(HtmlElementContext.class); | |
| } | |
| public HtmlElementContext htmlElement(int i) { | |
| return getRuleContext(HtmlElementContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public HtmlTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_htmlTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final HtmlTagContext htmlTag() throws RecognitionException { | |
| HtmlTagContext _localctx = new HtmlTagContext(_ctx, getState()); | |
| enterRule(_localctx, 10, RULE_htmlTag); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(326); | |
| ((HtmlTagContext)_localctx).htmlElementStart = htmlElementStart(); | |
| setState(336); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,13,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(334); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) { | |
| case 1: | |
| { | |
| setState(327); | |
| htmlElement(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| { | |
| setState(328); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(329); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(330); | |
| htmlComment(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(331); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(332); | |
| text(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(333); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(338); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,13,_ctx); | |
| } | |
| setState(339); | |
| ((HtmlTagContext)_localctx).htmlElementEnd = htmlElementEnd(); | |
| setState(340); | |
| if (!(isSameTagNames(((HtmlTagContext)_localctx).htmlElementStart, ((HtmlTagContext)_localctx).htmlElementEnd))) throw new FailedPredicateException(this, "isSameTagNames($htmlElementStart.ctx, $htmlElementEnd.ctx)"); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class PTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public PTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public PTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_pTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final PTagStartContext pTagStart(boolean isNonTight) throws RecognitionException { | |
| PTagStartContext _localctx = new PTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 12, RULE_pTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(342); | |
| match(START); | |
| setState(343); | |
| match(P_HTML_TAG_NAME); | |
| setState(350); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(348); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(344); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(345); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(346); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(347); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(352); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(353); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class PTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public PTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_pTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitPTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final PTagEndContext pTagEnd() throws RecognitionException { | |
| PTagEndContext _localctx = new PTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 14, RULE_pTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(355); | |
| match(START); | |
| setState(356); | |
| match(SLASH); | |
| setState(357); | |
| match(P_HTML_TAG_NAME); | |
| setState(361); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(358); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(363); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(364); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class ParagraphContext extends ParserRuleContext { | |
| public PTagStartContext pTagStart() { | |
| return getRuleContext(PTagStartContext.class,0); | |
| } | |
| public PTagEndContext pTagEnd() { | |
| return getRuleContext(PTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TheadContext> thead() { | |
| return getRuleContexts(TheadContext.class); | |
| } | |
| public TheadContext thead(int i) { | |
| return getRuleContext(TheadContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<OptgroupContext> optgroup() { | |
| return getRuleContexts(OptgroupContext.class); | |
| } | |
| public OptgroupContext optgroup(int i) { | |
| return getRuleContext(OptgroupContext.class,i); | |
| } | |
| public List<RbContext> rb() { | |
| return getRuleContexts(RbContext.class); | |
| } | |
| public RbContext rb(int i) { | |
| return getRuleContext(RbContext.class,i); | |
| } | |
| public List<RtContext> rt() { | |
| return getRuleContexts(RtContext.class); | |
| } | |
| public RtContext rt(int i) { | |
| return getRuleContext(RtContext.class,i); | |
| } | |
| public List<RtcContext> rtc() { | |
| return getRuleContexts(RtcContext.class); | |
| } | |
| public RtcContext rtc(int i) { | |
| return getRuleContext(RtcContext.class,i); | |
| } | |
| public List<RpContext> rp() { | |
| return getRuleContexts(RpContext.class); | |
| } | |
| public RpContext rp(int i) { | |
| return getRuleContext(RpContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TheadTagStartContext> theadTagStart() { | |
| return getRuleContexts(TheadTagStartContext.class); | |
| } | |
| public TheadTagStartContext theadTagStart(int i) { | |
| return getRuleContext(TheadTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<OptgroupTagStartContext> optgroupTagStart() { | |
| return getRuleContexts(OptgroupTagStartContext.class); | |
| } | |
| public OptgroupTagStartContext optgroupTagStart(int i) { | |
| return getRuleContext(OptgroupTagStartContext.class,i); | |
| } | |
| public List<RbTagStartContext> rbTagStart() { | |
| return getRuleContexts(RbTagStartContext.class); | |
| } | |
| public RbTagStartContext rbTagStart(int i) { | |
| return getRuleContext(RbTagStartContext.class,i); | |
| } | |
| public List<RtTagStartContext> rtTagStart() { | |
| return getRuleContexts(RtTagStartContext.class); | |
| } | |
| public RtTagStartContext rtTagStart(int i) { | |
| return getRuleContext(RtTagStartContext.class,i); | |
| } | |
| public List<RtcTagStartContext> rtcTagStart() { | |
| return getRuleContexts(RtcTagStartContext.class); | |
| } | |
| public RtcTagStartContext rtcTagStart(int i) { | |
| return getRuleContext(RtcTagStartContext.class,i); | |
| } | |
| public List<RpTagStartContext> rpTagStart() { | |
| return getRuleContexts(RpTagStartContext.class); | |
| } | |
| public RpTagStartContext rpTagStart(int i) { | |
| return getRuleContext(RpTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public ParagraphContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_paragraph; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParagraph(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final ParagraphContext paragraph() throws RecognitionException { | |
| ParagraphContext _localctx = new ParagraphContext(_ctx, getState()); | |
| enterRule(_localctx, 16, RULE_paragraph); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(366); | |
| pTagStart(false); | |
| setState(415); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,18,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(413); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { | |
| case 1: | |
| { | |
| setState(367); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(368); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(369); | |
| li(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(370); | |
| tr(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(371); | |
| td(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(372); | |
| th(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(373); | |
| body(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(374); | |
| colgroup(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(375); | |
| dd(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(376); | |
| dt(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(377); | |
| head(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(378); | |
| html(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(379); | |
| option(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(380); | |
| tbody(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(381); | |
| thead(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(382); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(383); | |
| optgroup(); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(384); | |
| rb(); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(385); | |
| rt(); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(386); | |
| rtc(); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(387); | |
| rp(); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(388); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(389); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(390); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(391); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(392); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(393); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(394); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(395); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(396); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| setState(397); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(398); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(399); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(400); | |
| theadTagStart(true); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(401); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 36: | |
| { | |
| setState(402); | |
| optgroupTagStart(true); | |
| } | |
| break; | |
| case 37: | |
| { | |
| setState(403); | |
| rbTagStart(true); | |
| } | |
| break; | |
| case 38: | |
| { | |
| setState(404); | |
| rtTagStart(true); | |
| } | |
| break; | |
| case 39: | |
| { | |
| setState(405); | |
| rtcTagStart(true); | |
| } | |
| break; | |
| case 40: | |
| { | |
| setState(406); | |
| rpTagStart(true); | |
| } | |
| break; | |
| case 41: | |
| { | |
| { | |
| setState(407); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(408); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 42: | |
| { | |
| setState(409); | |
| htmlComment(); | |
| } | |
| break; | |
| case 43: | |
| { | |
| setState(410); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 44: | |
| { | |
| setState(411); | |
| text(); | |
| } | |
| break; | |
| case 45: | |
| { | |
| setState(412); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(417); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,18,_ctx); | |
| } | |
| setState(418); | |
| pTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class LiTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public LiTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public LiTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_liTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final LiTagStartContext liTagStart(boolean isNonTight) throws RecognitionException { | |
| LiTagStartContext _localctx = new LiTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 18, RULE_liTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(420); | |
| match(START); | |
| setState(421); | |
| match(LI_HTML_TAG_NAME); | |
| setState(428); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(426); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(422); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(423); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(424); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(425); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(430); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(431); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class LiTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public LiTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_liTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLiTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final LiTagEndContext liTagEnd() throws RecognitionException { | |
| LiTagEndContext _localctx = new LiTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 20, RULE_liTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(433); | |
| match(START); | |
| setState(434); | |
| match(SLASH); | |
| setState(435); | |
| match(LI_HTML_TAG_NAME); | |
| setState(439); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(436); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(441); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(442); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class LiContext extends ParserRuleContext { | |
| public LiTagStartContext liTagStart() { | |
| return getRuleContext(LiTagStartContext.class,0); | |
| } | |
| public LiTagEndContext liTagEnd() { | |
| return getRuleContext(LiTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TheadContext> thead() { | |
| return getRuleContexts(TheadContext.class); | |
| } | |
| public TheadContext thead(int i) { | |
| return getRuleContext(TheadContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<OptgroupContext> optgroup() { | |
| return getRuleContexts(OptgroupContext.class); | |
| } | |
| public OptgroupContext optgroup(int i) { | |
| return getRuleContext(OptgroupContext.class,i); | |
| } | |
| public List<RbContext> rb() { | |
| return getRuleContexts(RbContext.class); | |
| } | |
| public RbContext rb(int i) { | |
| return getRuleContext(RbContext.class,i); | |
| } | |
| public List<RtContext> rt() { | |
| return getRuleContexts(RtContext.class); | |
| } | |
| public RtContext rt(int i) { | |
| return getRuleContext(RtContext.class,i); | |
| } | |
| public List<RtcContext> rtc() { | |
| return getRuleContexts(RtcContext.class); | |
| } | |
| public RtcContext rtc(int i) { | |
| return getRuleContext(RtcContext.class,i); | |
| } | |
| public List<RpContext> rp() { | |
| return getRuleContexts(RpContext.class); | |
| } | |
| public RpContext rp(int i) { | |
| return getRuleContext(RpContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TheadTagStartContext> theadTagStart() { | |
| return getRuleContexts(TheadTagStartContext.class); | |
| } | |
| public TheadTagStartContext theadTagStart(int i) { | |
| return getRuleContext(TheadTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<OptgroupTagStartContext> optgroupTagStart() { | |
| return getRuleContexts(OptgroupTagStartContext.class); | |
| } | |
| public OptgroupTagStartContext optgroupTagStart(int i) { | |
| return getRuleContext(OptgroupTagStartContext.class,i); | |
| } | |
| public List<RbTagStartContext> rbTagStart() { | |
| return getRuleContexts(RbTagStartContext.class); | |
| } | |
| public RbTagStartContext rbTagStart(int i) { | |
| return getRuleContext(RbTagStartContext.class,i); | |
| } | |
| public List<RtTagStartContext> rtTagStart() { | |
| return getRuleContexts(RtTagStartContext.class); | |
| } | |
| public RtTagStartContext rtTagStart(int i) { | |
| return getRuleContext(RtTagStartContext.class,i); | |
| } | |
| public List<RtcTagStartContext> rtcTagStart() { | |
| return getRuleContexts(RtcTagStartContext.class); | |
| } | |
| public RtcTagStartContext rtcTagStart(int i) { | |
| return getRuleContext(RtcTagStartContext.class,i); | |
| } | |
| public List<RpTagStartContext> rpTagStart() { | |
| return getRuleContexts(RpTagStartContext.class); | |
| } | |
| public RpTagStartContext rpTagStart(int i) { | |
| return getRuleContext(RpTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public LiContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_li; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLi(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final LiContext li() throws RecognitionException { | |
| LiContext _localctx = new LiContext(_ctx, getState()); | |
| enterRule(_localctx, 22, RULE_li); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(444); | |
| liTagStart(false); | |
| setState(493); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,23,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(491); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) { | |
| case 1: | |
| { | |
| setState(445); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(446); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(447); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(448); | |
| tr(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(449); | |
| td(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(450); | |
| th(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(451); | |
| body(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(452); | |
| colgroup(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(453); | |
| dd(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(454); | |
| dt(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(455); | |
| head(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(456); | |
| html(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(457); | |
| option(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(458); | |
| tbody(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(459); | |
| thead(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(460); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(461); | |
| optgroup(); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(462); | |
| rb(); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(463); | |
| rt(); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(464); | |
| rtc(); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(465); | |
| rp(); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(466); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(467); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(468); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(469); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(470); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(471); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(472); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(473); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(474); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| setState(475); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(476); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(477); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(478); | |
| theadTagStart(true); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(479); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 36: | |
| { | |
| setState(480); | |
| optgroupTagStart(true); | |
| } | |
| break; | |
| case 37: | |
| { | |
| setState(481); | |
| rbTagStart(true); | |
| } | |
| break; | |
| case 38: | |
| { | |
| setState(482); | |
| rtTagStart(true); | |
| } | |
| break; | |
| case 39: | |
| { | |
| setState(483); | |
| rtcTagStart(true); | |
| } | |
| break; | |
| case 40: | |
| { | |
| setState(484); | |
| rpTagStart(true); | |
| } | |
| break; | |
| case 41: | |
| { | |
| { | |
| setState(485); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(486); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 42: | |
| { | |
| setState(487); | |
| htmlComment(); | |
| } | |
| break; | |
| case 43: | |
| { | |
| setState(488); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 44: | |
| { | |
| setState(489); | |
| text(); | |
| } | |
| break; | |
| case 45: | |
| { | |
| setState(490); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(495); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,23,_ctx); | |
| } | |
| setState(496); | |
| liTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TrTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public TrTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public TrTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_trTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TrTagStartContext trTagStart(boolean isNonTight) throws RecognitionException { | |
| TrTagStartContext _localctx = new TrTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 24, RULE_trTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(498); | |
| match(START); | |
| setState(499); | |
| match(TR_HTML_TAG_NAME); | |
| setState(506); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(504); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(500); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(501); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(502); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(503); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(508); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(509); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TrTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public TrTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_trTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TrTagEndContext trTagEnd() throws RecognitionException { | |
| TrTagEndContext _localctx = new TrTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 26, RULE_trTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(511); | |
| match(START); | |
| setState(512); | |
| match(SLASH); | |
| setState(513); | |
| match(TR_HTML_TAG_NAME); | |
| setState(517); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(514); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(519); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(520); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TrContext extends ParserRuleContext { | |
| public TrTagStartContext trTagStart() { | |
| return getRuleContext(TrTagStartContext.class,0); | |
| } | |
| public TrTagEndContext trTagEnd() { | |
| return getRuleContext(TrTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TheadContext> thead() { | |
| return getRuleContexts(TheadContext.class); | |
| } | |
| public TheadContext thead(int i) { | |
| return getRuleContext(TheadContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<OptgroupContext> optgroup() { | |
| return getRuleContexts(OptgroupContext.class); | |
| } | |
| public OptgroupContext optgroup(int i) { | |
| return getRuleContext(OptgroupContext.class,i); | |
| } | |
| public List<RbContext> rb() { | |
| return getRuleContexts(RbContext.class); | |
| } | |
| public RbContext rb(int i) { | |
| return getRuleContext(RbContext.class,i); | |
| } | |
| public List<RtContext> rt() { | |
| return getRuleContexts(RtContext.class); | |
| } | |
| public RtContext rt(int i) { | |
| return getRuleContext(RtContext.class,i); | |
| } | |
| public List<RtcContext> rtc() { | |
| return getRuleContexts(RtcContext.class); | |
| } | |
| public RtcContext rtc(int i) { | |
| return getRuleContext(RtcContext.class,i); | |
| } | |
| public List<RpContext> rp() { | |
| return getRuleContexts(RpContext.class); | |
| } | |
| public RpContext rp(int i) { | |
| return getRuleContext(RpContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TheadTagStartContext> theadTagStart() { | |
| return getRuleContexts(TheadTagStartContext.class); | |
| } | |
| public TheadTagStartContext theadTagStart(int i) { | |
| return getRuleContext(TheadTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<OptgroupTagStartContext> optgroupTagStart() { | |
| return getRuleContexts(OptgroupTagStartContext.class); | |
| } | |
| public OptgroupTagStartContext optgroupTagStart(int i) { | |
| return getRuleContext(OptgroupTagStartContext.class,i); | |
| } | |
| public List<RbTagStartContext> rbTagStart() { | |
| return getRuleContexts(RbTagStartContext.class); | |
| } | |
| public RbTagStartContext rbTagStart(int i) { | |
| return getRuleContext(RbTagStartContext.class,i); | |
| } | |
| public List<RtTagStartContext> rtTagStart() { | |
| return getRuleContexts(RtTagStartContext.class); | |
| } | |
| public RtTagStartContext rtTagStart(int i) { | |
| return getRuleContext(RtTagStartContext.class,i); | |
| } | |
| public List<RtcTagStartContext> rtcTagStart() { | |
| return getRuleContexts(RtcTagStartContext.class); | |
| } | |
| public RtcTagStartContext rtcTagStart(int i) { | |
| return getRuleContext(RtcTagStartContext.class,i); | |
| } | |
| public List<RpTagStartContext> rpTagStart() { | |
| return getRuleContexts(RpTagStartContext.class); | |
| } | |
| public RpTagStartContext rpTagStart(int i) { | |
| return getRuleContext(RpTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public TrContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_tr; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTr(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TrContext tr() throws RecognitionException { | |
| TrContext _localctx = new TrContext(_ctx, getState()); | |
| enterRule(_localctx, 28, RULE_tr); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(522); | |
| trTagStart(false); | |
| setState(571); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,28,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(569); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) { | |
| case 1: | |
| { | |
| setState(523); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(524); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(525); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(526); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(527); | |
| td(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(528); | |
| th(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(529); | |
| body(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(530); | |
| colgroup(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(531); | |
| dd(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(532); | |
| dt(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(533); | |
| head(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(534); | |
| html(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(535); | |
| option(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(536); | |
| tbody(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(537); | |
| thead(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(538); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(539); | |
| optgroup(); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(540); | |
| rb(); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(541); | |
| rt(); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(542); | |
| rtc(); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(543); | |
| rp(); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(544); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(545); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(546); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(547); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(548); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(549); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(550); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(551); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(552); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| setState(553); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(554); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(555); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(556); | |
| theadTagStart(true); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(557); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 36: | |
| { | |
| setState(558); | |
| optgroupTagStart(true); | |
| } | |
| break; | |
| case 37: | |
| { | |
| setState(559); | |
| rbTagStart(true); | |
| } | |
| break; | |
| case 38: | |
| { | |
| setState(560); | |
| rtTagStart(true); | |
| } | |
| break; | |
| case 39: | |
| { | |
| setState(561); | |
| rtcTagStart(true); | |
| } | |
| break; | |
| case 40: | |
| { | |
| setState(562); | |
| rpTagStart(true); | |
| } | |
| break; | |
| case 41: | |
| { | |
| { | |
| setState(563); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(564); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 42: | |
| { | |
| setState(565); | |
| htmlComment(); | |
| } | |
| break; | |
| case 43: | |
| { | |
| setState(566); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 44: | |
| { | |
| setState(567); | |
| text(); | |
| } | |
| break; | |
| case 45: | |
| { | |
| setState(568); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(573); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,28,_ctx); | |
| } | |
| setState(574); | |
| trTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TdTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public TdTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public TdTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_tdTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TdTagStartContext tdTagStart(boolean isNonTight) throws RecognitionException { | |
| TdTagStartContext _localctx = new TdTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 30, RULE_tdTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(576); | |
| match(START); | |
| setState(577); | |
| match(TD_HTML_TAG_NAME); | |
| setState(584); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(582); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(578); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(579); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(580); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(581); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(586); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(587); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TdTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public TdTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_tdTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTdTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TdTagEndContext tdTagEnd() throws RecognitionException { | |
| TdTagEndContext _localctx = new TdTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 32, RULE_tdTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(589); | |
| match(START); | |
| setState(590); | |
| match(SLASH); | |
| setState(591); | |
| match(TD_HTML_TAG_NAME); | |
| setState(595); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(592); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(597); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(598); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TdContext extends ParserRuleContext { | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public TdTagEndContext tdTagEnd() { | |
| return getRuleContext(TdTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TheadContext> thead() { | |
| return getRuleContexts(TheadContext.class); | |
| } | |
| public TheadContext thead(int i) { | |
| return getRuleContext(TheadContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<OptgroupContext> optgroup() { | |
| return getRuleContexts(OptgroupContext.class); | |
| } | |
| public OptgroupContext optgroup(int i) { | |
| return getRuleContext(OptgroupContext.class,i); | |
| } | |
| public List<RbContext> rb() { | |
| return getRuleContexts(RbContext.class); | |
| } | |
| public RbContext rb(int i) { | |
| return getRuleContext(RbContext.class,i); | |
| } | |
| public List<RtContext> rt() { | |
| return getRuleContexts(RtContext.class); | |
| } | |
| public RtContext rt(int i) { | |
| return getRuleContext(RtContext.class,i); | |
| } | |
| public List<RtcContext> rtc() { | |
| return getRuleContexts(RtcContext.class); | |
| } | |
| public RtcContext rtc(int i) { | |
| return getRuleContext(RtcContext.class,i); | |
| } | |
| public List<RpContext> rp() { | |
| return getRuleContexts(RpContext.class); | |
| } | |
| public RpContext rp(int i) { | |
| return getRuleContext(RpContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TheadTagStartContext> theadTagStart() { | |
| return getRuleContexts(TheadTagStartContext.class); | |
| } | |
| public TheadTagStartContext theadTagStart(int i) { | |
| return getRuleContext(TheadTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<OptgroupTagStartContext> optgroupTagStart() { | |
| return getRuleContexts(OptgroupTagStartContext.class); | |
| } | |
| public OptgroupTagStartContext optgroupTagStart(int i) { | |
| return getRuleContext(OptgroupTagStartContext.class,i); | |
| } | |
| public List<RbTagStartContext> rbTagStart() { | |
| return getRuleContexts(RbTagStartContext.class); | |
| } | |
| public RbTagStartContext rbTagStart(int i) { | |
| return getRuleContext(RbTagStartContext.class,i); | |
| } | |
| public List<RtTagStartContext> rtTagStart() { | |
| return getRuleContexts(RtTagStartContext.class); | |
| } | |
| public RtTagStartContext rtTagStart(int i) { | |
| return getRuleContext(RtTagStartContext.class,i); | |
| } | |
| public List<RtcTagStartContext> rtcTagStart() { | |
| return getRuleContexts(RtcTagStartContext.class); | |
| } | |
| public RtcTagStartContext rtcTagStart(int i) { | |
| return getRuleContext(RtcTagStartContext.class,i); | |
| } | |
| public List<RpTagStartContext> rpTagStart() { | |
| return getRuleContexts(RpTagStartContext.class); | |
| } | |
| public RpTagStartContext rpTagStart(int i) { | |
| return getRuleContext(RpTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public TdContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_td; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TdContext td() throws RecognitionException { | |
| TdContext _localctx = new TdContext(_ctx, getState()); | |
| enterRule(_localctx, 34, RULE_td); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(600); | |
| tdTagStart(false); | |
| setState(649); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,33,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(647); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) { | |
| case 1: | |
| { | |
| setState(601); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(602); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(603); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(604); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(605); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(606); | |
| th(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(607); | |
| body(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(608); | |
| colgroup(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(609); | |
| dd(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(610); | |
| dt(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(611); | |
| head(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(612); | |
| html(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(613); | |
| option(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(614); | |
| tbody(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(615); | |
| thead(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(616); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(617); | |
| optgroup(); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(618); | |
| rb(); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(619); | |
| rt(); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(620); | |
| rtc(); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(621); | |
| rp(); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(622); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(623); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(624); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(625); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(626); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(627); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(628); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(629); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(630); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| setState(631); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(632); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(633); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(634); | |
| theadTagStart(true); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(635); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 36: | |
| { | |
| setState(636); | |
| optgroupTagStart(true); | |
| } | |
| break; | |
| case 37: | |
| { | |
| setState(637); | |
| rbTagStart(true); | |
| } | |
| break; | |
| case 38: | |
| { | |
| setState(638); | |
| rtTagStart(true); | |
| } | |
| break; | |
| case 39: | |
| { | |
| setState(639); | |
| rtcTagStart(true); | |
| } | |
| break; | |
| case 40: | |
| { | |
| setState(640); | |
| rpTagStart(true); | |
| } | |
| break; | |
| case 41: | |
| { | |
| { | |
| setState(641); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(642); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 42: | |
| { | |
| setState(643); | |
| htmlComment(); | |
| } | |
| break; | |
| case 43: | |
| { | |
| setState(644); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 44: | |
| { | |
| setState(645); | |
| text(); | |
| } | |
| break; | |
| case 45: | |
| { | |
| setState(646); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(651); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,33,_ctx); | |
| } | |
| setState(652); | |
| tdTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class ThTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public ThTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public ThTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_thTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final ThTagStartContext thTagStart(boolean isNonTight) throws RecognitionException { | |
| ThTagStartContext _localctx = new ThTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 36, RULE_thTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(654); | |
| match(START); | |
| setState(655); | |
| match(TH_HTML_TAG_NAME); | |
| setState(662); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(660); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(656); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(657); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(658); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(659); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(664); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(665); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class ThTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public ThTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_thTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final ThTagEndContext thTagEnd() throws RecognitionException { | |
| ThTagEndContext _localctx = new ThTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 38, RULE_thTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(667); | |
| match(START); | |
| setState(668); | |
| match(SLASH); | |
| setState(669); | |
| match(TH_HTML_TAG_NAME); | |
| setState(673); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(670); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(675); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(676); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class ThContext extends ParserRuleContext { | |
| public ThTagStartContext thTagStart() { | |
| return getRuleContext(ThTagStartContext.class,0); | |
| } | |
| public ThTagEndContext thTagEnd() { | |
| return getRuleContext(ThTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TheadContext> thead() { | |
| return getRuleContexts(TheadContext.class); | |
| } | |
| public TheadContext thead(int i) { | |
| return getRuleContext(TheadContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<OptgroupContext> optgroup() { | |
| return getRuleContexts(OptgroupContext.class); | |
| } | |
| public OptgroupContext optgroup(int i) { | |
| return getRuleContext(OptgroupContext.class,i); | |
| } | |
| public List<RbContext> rb() { | |
| return getRuleContexts(RbContext.class); | |
| } | |
| public RbContext rb(int i) { | |
| return getRuleContext(RbContext.class,i); | |
| } | |
| public List<RtContext> rt() { | |
| return getRuleContexts(RtContext.class); | |
| } | |
| public RtContext rt(int i) { | |
| return getRuleContext(RtContext.class,i); | |
| } | |
| public List<RtcContext> rtc() { | |
| return getRuleContexts(RtcContext.class); | |
| } | |
| public RtcContext rtc(int i) { | |
| return getRuleContext(RtcContext.class,i); | |
| } | |
| public List<RpContext> rp() { | |
| return getRuleContexts(RpContext.class); | |
| } | |
| public RpContext rp(int i) { | |
| return getRuleContext(RpContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TheadTagStartContext> theadTagStart() { | |
| return getRuleContexts(TheadTagStartContext.class); | |
| } | |
| public TheadTagStartContext theadTagStart(int i) { | |
| return getRuleContext(TheadTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<OptgroupTagStartContext> optgroupTagStart() { | |
| return getRuleContexts(OptgroupTagStartContext.class); | |
| } | |
| public OptgroupTagStartContext optgroupTagStart(int i) { | |
| return getRuleContext(OptgroupTagStartContext.class,i); | |
| } | |
| public List<RbTagStartContext> rbTagStart() { | |
| return getRuleContexts(RbTagStartContext.class); | |
| } | |
| public RbTagStartContext rbTagStart(int i) { | |
| return getRuleContext(RbTagStartContext.class,i); | |
| } | |
| public List<RtTagStartContext> rtTagStart() { | |
| return getRuleContexts(RtTagStartContext.class); | |
| } | |
| public RtTagStartContext rtTagStart(int i) { | |
| return getRuleContext(RtTagStartContext.class,i); | |
| } | |
| public List<RtcTagStartContext> rtcTagStart() { | |
| return getRuleContexts(RtcTagStartContext.class); | |
| } | |
| public RtcTagStartContext rtcTagStart(int i) { | |
| return getRuleContext(RtcTagStartContext.class,i); | |
| } | |
| public List<RpTagStartContext> rpTagStart() { | |
| return getRuleContexts(RpTagStartContext.class); | |
| } | |
| public RpTagStartContext rpTagStart(int i) { | |
| return getRuleContext(RpTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public ThContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_th; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTh(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final ThContext th() throws RecognitionException { | |
| ThContext _localctx = new ThContext(_ctx, getState()); | |
| enterRule(_localctx, 40, RULE_th); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(678); | |
| thTagStart(false); | |
| setState(727); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,38,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(725); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { | |
| case 1: | |
| { | |
| setState(679); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(680); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(681); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(682); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(683); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(684); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(685); | |
| body(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(686); | |
| colgroup(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(687); | |
| dd(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(688); | |
| dt(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(689); | |
| head(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(690); | |
| html(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(691); | |
| option(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(692); | |
| tbody(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(693); | |
| thead(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(694); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(695); | |
| optgroup(); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(696); | |
| rb(); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(697); | |
| rt(); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(698); | |
| rtc(); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(699); | |
| rp(); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(700); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(701); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(702); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(703); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(704); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(705); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(706); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(707); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(708); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| setState(709); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(710); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(711); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(712); | |
| theadTagStart(true); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(713); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 36: | |
| { | |
| setState(714); | |
| optgroupTagStart(true); | |
| } | |
| break; | |
| case 37: | |
| { | |
| setState(715); | |
| rbTagStart(true); | |
| } | |
| break; | |
| case 38: | |
| { | |
| setState(716); | |
| rtTagStart(true); | |
| } | |
| break; | |
| case 39: | |
| { | |
| setState(717); | |
| rtcTagStart(true); | |
| } | |
| break; | |
| case 40: | |
| { | |
| setState(718); | |
| rpTagStart(true); | |
| } | |
| break; | |
| case 41: | |
| { | |
| { | |
| setState(719); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(720); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 42: | |
| { | |
| setState(721); | |
| htmlComment(); | |
| } | |
| break; | |
| case 43: | |
| { | |
| setState(722); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 44: | |
| { | |
| setState(723); | |
| text(); | |
| } | |
| break; | |
| case 45: | |
| { | |
| setState(724); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(729); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,38,_ctx); | |
| } | |
| setState(730); | |
| thTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class BodyTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public BodyTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public BodyTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_bodyTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final BodyTagStartContext bodyTagStart(boolean isNonTight) throws RecognitionException { | |
| BodyTagStartContext _localctx = new BodyTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 42, RULE_bodyTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(732); | |
| match(START); | |
| setState(733); | |
| match(BODY_HTML_TAG_NAME); | |
| setState(740); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(738); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(734); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(735); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(736); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(737); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(742); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(743); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class BodyTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public BodyTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_bodyTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBodyTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final BodyTagEndContext bodyTagEnd() throws RecognitionException { | |
| BodyTagEndContext _localctx = new BodyTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 44, RULE_bodyTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(745); | |
| match(START); | |
| setState(746); | |
| match(SLASH); | |
| setState(747); | |
| match(BODY_HTML_TAG_NAME); | |
| setState(751); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(748); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(753); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(754); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class BodyContext extends ParserRuleContext { | |
| public BodyTagStartContext bodyTagStart() { | |
| return getRuleContext(BodyTagStartContext.class,0); | |
| } | |
| public BodyTagEndContext bodyTagEnd() { | |
| return getRuleContext(BodyTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TheadContext> thead() { | |
| return getRuleContexts(TheadContext.class); | |
| } | |
| public TheadContext thead(int i) { | |
| return getRuleContext(TheadContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<OptgroupContext> optgroup() { | |
| return getRuleContexts(OptgroupContext.class); | |
| } | |
| public OptgroupContext optgroup(int i) { | |
| return getRuleContext(OptgroupContext.class,i); | |
| } | |
| public List<RbContext> rb() { | |
| return getRuleContexts(RbContext.class); | |
| } | |
| public RbContext rb(int i) { | |
| return getRuleContext(RbContext.class,i); | |
| } | |
| public List<RtContext> rt() { | |
| return getRuleContexts(RtContext.class); | |
| } | |
| public RtContext rt(int i) { | |
| return getRuleContext(RtContext.class,i); | |
| } | |
| public List<RtcContext> rtc() { | |
| return getRuleContexts(RtcContext.class); | |
| } | |
| public RtcContext rtc(int i) { | |
| return getRuleContext(RtcContext.class,i); | |
| } | |
| public List<RpContext> rp() { | |
| return getRuleContexts(RpContext.class); | |
| } | |
| public RpContext rp(int i) { | |
| return getRuleContext(RpContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TheadTagStartContext> theadTagStart() { | |
| return getRuleContexts(TheadTagStartContext.class); | |
| } | |
| public TheadTagStartContext theadTagStart(int i) { | |
| return getRuleContext(TheadTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<OptgroupTagStartContext> optgroupTagStart() { | |
| return getRuleContexts(OptgroupTagStartContext.class); | |
| } | |
| public OptgroupTagStartContext optgroupTagStart(int i) { | |
| return getRuleContext(OptgroupTagStartContext.class,i); | |
| } | |
| public List<RbTagStartContext> rbTagStart() { | |
| return getRuleContexts(RbTagStartContext.class); | |
| } | |
| public RbTagStartContext rbTagStart(int i) { | |
| return getRuleContext(RbTagStartContext.class,i); | |
| } | |
| public List<RtTagStartContext> rtTagStart() { | |
| return getRuleContexts(RtTagStartContext.class); | |
| } | |
| public RtTagStartContext rtTagStart(int i) { | |
| return getRuleContext(RtTagStartContext.class,i); | |
| } | |
| public List<RtcTagStartContext> rtcTagStart() { | |
| return getRuleContexts(RtcTagStartContext.class); | |
| } | |
| public RtcTagStartContext rtcTagStart(int i) { | |
| return getRuleContext(RtcTagStartContext.class,i); | |
| } | |
| public List<RpTagStartContext> rpTagStart() { | |
| return getRuleContexts(RpTagStartContext.class); | |
| } | |
| public RpTagStartContext rpTagStart(int i) { | |
| return getRuleContext(RpTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public BodyContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_body; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBody(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final BodyContext body() throws RecognitionException { | |
| BodyContext _localctx = new BodyContext(_ctx, getState()); | |
| enterRule(_localctx, 46, RULE_body); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(756); | |
| bodyTagStart(false); | |
| setState(805); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,43,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(803); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) { | |
| case 1: | |
| { | |
| setState(757); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(758); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(759); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(760); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(761); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(762); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(763); | |
| th(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(764); | |
| colgroup(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(765); | |
| dd(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(766); | |
| dt(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(767); | |
| head(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(768); | |
| html(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(769); | |
| option(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(770); | |
| tbody(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(771); | |
| thead(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(772); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(773); | |
| optgroup(); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(774); | |
| rb(); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(775); | |
| rt(); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(776); | |
| rtc(); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(777); | |
| rp(); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(778); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(779); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(780); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(781); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(782); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(783); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(784); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(785); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(786); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| setState(787); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(788); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(789); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(790); | |
| theadTagStart(true); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(791); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 36: | |
| { | |
| setState(792); | |
| optgroupTagStart(true); | |
| } | |
| break; | |
| case 37: | |
| { | |
| setState(793); | |
| rbTagStart(true); | |
| } | |
| break; | |
| case 38: | |
| { | |
| setState(794); | |
| rtTagStart(true); | |
| } | |
| break; | |
| case 39: | |
| { | |
| setState(795); | |
| rtcTagStart(true); | |
| } | |
| break; | |
| case 40: | |
| { | |
| setState(796); | |
| rpTagStart(true); | |
| } | |
| break; | |
| case 41: | |
| { | |
| { | |
| setState(797); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(798); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 42: | |
| { | |
| setState(799); | |
| htmlComment(); | |
| } | |
| break; | |
| case 43: | |
| { | |
| setState(800); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 44: | |
| { | |
| setState(801); | |
| text(); | |
| } | |
| break; | |
| case 45: | |
| { | |
| setState(802); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(807); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,43,_ctx); | |
| } | |
| setState(808); | |
| bodyTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class ColgroupTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public ColgroupTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public ColgroupTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_colgroupTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final ColgroupTagStartContext colgroupTagStart(boolean isNonTight) throws RecognitionException { | |
| ColgroupTagStartContext _localctx = new ColgroupTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 48, RULE_colgroupTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(810); | |
| match(START); | |
| setState(811); | |
| match(COLGROUP_HTML_TAG_NAME); | |
| setState(818); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(816); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(812); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(813); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(814); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(815); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(820); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(821); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class ColgroupTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public ColgroupTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_colgroupTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroupTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final ColgroupTagEndContext colgroupTagEnd() throws RecognitionException { | |
| ColgroupTagEndContext _localctx = new ColgroupTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 50, RULE_colgroupTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(823); | |
| match(START); | |
| setState(824); | |
| match(SLASH); | |
| setState(825); | |
| match(COLGROUP_HTML_TAG_NAME); | |
| setState(829); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(826); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(831); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(832); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class ColgroupContext extends ParserRuleContext { | |
| public ColgroupTagStartContext colgroupTagStart() { | |
| return getRuleContext(ColgroupTagStartContext.class,0); | |
| } | |
| public ColgroupTagEndContext colgroupTagEnd() { | |
| return getRuleContext(ColgroupTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TheadContext> thead() { | |
| return getRuleContexts(TheadContext.class); | |
| } | |
| public TheadContext thead(int i) { | |
| return getRuleContext(TheadContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<OptgroupContext> optgroup() { | |
| return getRuleContexts(OptgroupContext.class); | |
| } | |
| public OptgroupContext optgroup(int i) { | |
| return getRuleContext(OptgroupContext.class,i); | |
| } | |
| public List<RbContext> rb() { | |
| return getRuleContexts(RbContext.class); | |
| } | |
| public RbContext rb(int i) { | |
| return getRuleContext(RbContext.class,i); | |
| } | |
| public List<RtContext> rt() { | |
| return getRuleContexts(RtContext.class); | |
| } | |
| public RtContext rt(int i) { | |
| return getRuleContext(RtContext.class,i); | |
| } | |
| public List<RtcContext> rtc() { | |
| return getRuleContexts(RtcContext.class); | |
| } | |
| public RtcContext rtc(int i) { | |
| return getRuleContext(RtcContext.class,i); | |
| } | |
| public List<RpContext> rp() { | |
| return getRuleContexts(RpContext.class); | |
| } | |
| public RpContext rp(int i) { | |
| return getRuleContext(RpContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TheadTagStartContext> theadTagStart() { | |
| return getRuleContexts(TheadTagStartContext.class); | |
| } | |
| public TheadTagStartContext theadTagStart(int i) { | |
| return getRuleContext(TheadTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<OptgroupTagStartContext> optgroupTagStart() { | |
| return getRuleContexts(OptgroupTagStartContext.class); | |
| } | |
| public OptgroupTagStartContext optgroupTagStart(int i) { | |
| return getRuleContext(OptgroupTagStartContext.class,i); | |
| } | |
| public List<RbTagStartContext> rbTagStart() { | |
| return getRuleContexts(RbTagStartContext.class); | |
| } | |
| public RbTagStartContext rbTagStart(int i) { | |
| return getRuleContext(RbTagStartContext.class,i); | |
| } | |
| public List<RtTagStartContext> rtTagStart() { | |
| return getRuleContexts(RtTagStartContext.class); | |
| } | |
| public RtTagStartContext rtTagStart(int i) { | |
| return getRuleContext(RtTagStartContext.class,i); | |
| } | |
| public List<RtcTagStartContext> rtcTagStart() { | |
| return getRuleContexts(RtcTagStartContext.class); | |
| } | |
| public RtcTagStartContext rtcTagStart(int i) { | |
| return getRuleContext(RtcTagStartContext.class,i); | |
| } | |
| public List<RpTagStartContext> rpTagStart() { | |
| return getRuleContexts(RpTagStartContext.class); | |
| } | |
| public RpTagStartContext rpTagStart(int i) { | |
| return getRuleContext(RpTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public ColgroupContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_colgroup; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColgroup(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final ColgroupContext colgroup() throws RecognitionException { | |
| ColgroupContext _localctx = new ColgroupContext(_ctx, getState()); | |
| enterRule(_localctx, 52, RULE_colgroup); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(834); | |
| colgroupTagStart(false); | |
| setState(883); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,48,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(881); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) { | |
| case 1: | |
| { | |
| setState(835); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(836); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(837); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(838); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(839); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(840); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(841); | |
| th(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(842); | |
| body(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(843); | |
| dd(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(844); | |
| dt(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(845); | |
| head(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(846); | |
| html(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(847); | |
| option(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(848); | |
| tbody(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(849); | |
| thead(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(850); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(851); | |
| optgroup(); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(852); | |
| rb(); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(853); | |
| rt(); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(854); | |
| rtc(); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(855); | |
| rp(); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(856); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(857); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(858); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(859); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(860); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(861); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(862); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(863); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(864); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| setState(865); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(866); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(867); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(868); | |
| theadTagStart(true); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(869); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 36: | |
| { | |
| setState(870); | |
| optgroupTagStart(true); | |
| } | |
| break; | |
| case 37: | |
| { | |
| setState(871); | |
| rbTagStart(true); | |
| } | |
| break; | |
| case 38: | |
| { | |
| setState(872); | |
| rtTagStart(true); | |
| } | |
| break; | |
| case 39: | |
| { | |
| setState(873); | |
| rtcTagStart(true); | |
| } | |
| break; | |
| case 40: | |
| { | |
| setState(874); | |
| rpTagStart(true); | |
| } | |
| break; | |
| case 41: | |
| { | |
| { | |
| setState(875); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(876); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 42: | |
| { | |
| setState(877); | |
| htmlComment(); | |
| } | |
| break; | |
| case 43: | |
| { | |
| setState(878); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 44: | |
| { | |
| setState(879); | |
| text(); | |
| } | |
| break; | |
| case 45: | |
| { | |
| setState(880); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(885); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,48,_ctx); | |
| } | |
| setState(886); | |
| colgroupTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class DdTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public DdTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public DdTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_ddTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final DdTagStartContext ddTagStart(boolean isNonTight) throws RecognitionException { | |
| DdTagStartContext _localctx = new DdTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 54, RULE_ddTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(888); | |
| match(START); | |
| setState(889); | |
| match(DD_HTML_TAG_NAME); | |
| setState(896); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(894); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(890); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(891); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(892); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(893); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(898); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(899); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class DdTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public DdTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_ddTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDdTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final DdTagEndContext ddTagEnd() throws RecognitionException { | |
| DdTagEndContext _localctx = new DdTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 56, RULE_ddTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(901); | |
| match(START); | |
| setState(902); | |
| match(SLASH); | |
| setState(903); | |
| match(DD_HTML_TAG_NAME); | |
| setState(907); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(904); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(909); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(910); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class DdContext extends ParserRuleContext { | |
| public DdTagStartContext ddTagStart() { | |
| return getRuleContext(DdTagStartContext.class,0); | |
| } | |
| public DdTagEndContext ddTagEnd() { | |
| return getRuleContext(DdTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TheadContext> thead() { | |
| return getRuleContexts(TheadContext.class); | |
| } | |
| public TheadContext thead(int i) { | |
| return getRuleContext(TheadContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<OptgroupContext> optgroup() { | |
| return getRuleContexts(OptgroupContext.class); | |
| } | |
| public OptgroupContext optgroup(int i) { | |
| return getRuleContext(OptgroupContext.class,i); | |
| } | |
| public List<RbContext> rb() { | |
| return getRuleContexts(RbContext.class); | |
| } | |
| public RbContext rb(int i) { | |
| return getRuleContext(RbContext.class,i); | |
| } | |
| public List<RtContext> rt() { | |
| return getRuleContexts(RtContext.class); | |
| } | |
| public RtContext rt(int i) { | |
| return getRuleContext(RtContext.class,i); | |
| } | |
| public List<RtcContext> rtc() { | |
| return getRuleContexts(RtcContext.class); | |
| } | |
| public RtcContext rtc(int i) { | |
| return getRuleContext(RtcContext.class,i); | |
| } | |
| public List<RpContext> rp() { | |
| return getRuleContexts(RpContext.class); | |
| } | |
| public RpContext rp(int i) { | |
| return getRuleContext(RpContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TheadTagStartContext> theadTagStart() { | |
| return getRuleContexts(TheadTagStartContext.class); | |
| } | |
| public TheadTagStartContext theadTagStart(int i) { | |
| return getRuleContext(TheadTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<OptgroupTagStartContext> optgroupTagStart() { | |
| return getRuleContexts(OptgroupTagStartContext.class); | |
| } | |
| public OptgroupTagStartContext optgroupTagStart(int i) { | |
| return getRuleContext(OptgroupTagStartContext.class,i); | |
| } | |
| public List<RbTagStartContext> rbTagStart() { | |
| return getRuleContexts(RbTagStartContext.class); | |
| } | |
| public RbTagStartContext rbTagStart(int i) { | |
| return getRuleContext(RbTagStartContext.class,i); | |
| } | |
| public List<RtTagStartContext> rtTagStart() { | |
| return getRuleContexts(RtTagStartContext.class); | |
| } | |
| public RtTagStartContext rtTagStart(int i) { | |
| return getRuleContext(RtTagStartContext.class,i); | |
| } | |
| public List<RtcTagStartContext> rtcTagStart() { | |
| return getRuleContexts(RtcTagStartContext.class); | |
| } | |
| public RtcTagStartContext rtcTagStart(int i) { | |
| return getRuleContext(RtcTagStartContext.class,i); | |
| } | |
| public List<RpTagStartContext> rpTagStart() { | |
| return getRuleContexts(RpTagStartContext.class); | |
| } | |
| public RpTagStartContext rpTagStart(int i) { | |
| return getRuleContext(RpTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public DdContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_dd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final DdContext dd() throws RecognitionException { | |
| DdContext _localctx = new DdContext(_ctx, getState()); | |
| enterRule(_localctx, 58, RULE_dd); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(912); | |
| ddTagStart(false); | |
| setState(961); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,53,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(959); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) { | |
| case 1: | |
| { | |
| setState(913); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(914); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(915); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(916); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(917); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(918); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(919); | |
| th(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(920); | |
| body(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(921); | |
| colgroup(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(922); | |
| dt(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(923); | |
| head(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(924); | |
| html(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(925); | |
| option(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(926); | |
| tbody(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(927); | |
| thead(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(928); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(929); | |
| optgroup(); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(930); | |
| rb(); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(931); | |
| rt(); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(932); | |
| rtc(); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(933); | |
| rp(); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(934); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(935); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(936); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(937); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(938); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(939); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(940); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(941); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(942); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| setState(943); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(944); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(945); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(946); | |
| theadTagStart(true); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(947); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 36: | |
| { | |
| setState(948); | |
| optgroupTagStart(true); | |
| } | |
| break; | |
| case 37: | |
| { | |
| setState(949); | |
| rbTagStart(true); | |
| } | |
| break; | |
| case 38: | |
| { | |
| setState(950); | |
| rtTagStart(true); | |
| } | |
| break; | |
| case 39: | |
| { | |
| setState(951); | |
| rtcTagStart(true); | |
| } | |
| break; | |
| case 40: | |
| { | |
| setState(952); | |
| rpTagStart(true); | |
| } | |
| break; | |
| case 41: | |
| { | |
| { | |
| setState(953); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(954); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 42: | |
| { | |
| setState(955); | |
| htmlComment(); | |
| } | |
| break; | |
| case 43: | |
| { | |
| setState(956); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 44: | |
| { | |
| setState(957); | |
| text(); | |
| } | |
| break; | |
| case 45: | |
| { | |
| setState(958); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(963); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,53,_ctx); | |
| } | |
| setState(964); | |
| ddTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class DtTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public DtTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public DtTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_dtTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final DtTagStartContext dtTagStart(boolean isNonTight) throws RecognitionException { | |
| DtTagStartContext _localctx = new DtTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 60, RULE_dtTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(966); | |
| match(START); | |
| setState(967); | |
| match(DT_HTML_TAG_NAME); | |
| setState(974); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(972); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(968); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(969); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(970); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(971); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(976); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(977); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class DtTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public DtTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_dtTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDtTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final DtTagEndContext dtTagEnd() throws RecognitionException { | |
| DtTagEndContext _localctx = new DtTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 62, RULE_dtTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(979); | |
| match(START); | |
| setState(980); | |
| match(SLASH); | |
| setState(981); | |
| match(DT_HTML_TAG_NAME); | |
| setState(985); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(982); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(987); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(988); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class DtContext extends ParserRuleContext { | |
| public DtTagStartContext dtTagStart() { | |
| return getRuleContext(DtTagStartContext.class,0); | |
| } | |
| public DtTagEndContext dtTagEnd() { | |
| return getRuleContext(DtTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TheadContext> thead() { | |
| return getRuleContexts(TheadContext.class); | |
| } | |
| public TheadContext thead(int i) { | |
| return getRuleContext(TheadContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<OptgroupContext> optgroup() { | |
| return getRuleContexts(OptgroupContext.class); | |
| } | |
| public OptgroupContext optgroup(int i) { | |
| return getRuleContext(OptgroupContext.class,i); | |
| } | |
| public List<RbContext> rb() { | |
| return getRuleContexts(RbContext.class); | |
| } | |
| public RbContext rb(int i) { | |
| return getRuleContext(RbContext.class,i); | |
| } | |
| public List<RtContext> rt() { | |
| return getRuleContexts(RtContext.class); | |
| } | |
| public RtContext rt(int i) { | |
| return getRuleContext(RtContext.class,i); | |
| } | |
| public List<RtcContext> rtc() { | |
| return getRuleContexts(RtcContext.class); | |
| } | |
| public RtcContext rtc(int i) { | |
| return getRuleContext(RtcContext.class,i); | |
| } | |
| public List<RpContext> rp() { | |
| return getRuleContexts(RpContext.class); | |
| } | |
| public RpContext rp(int i) { | |
| return getRuleContext(RpContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TheadTagStartContext> theadTagStart() { | |
| return getRuleContexts(TheadTagStartContext.class); | |
| } | |
| public TheadTagStartContext theadTagStart(int i) { | |
| return getRuleContext(TheadTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<OptgroupTagStartContext> optgroupTagStart() { | |
| return getRuleContexts(OptgroupTagStartContext.class); | |
| } | |
| public OptgroupTagStartContext optgroupTagStart(int i) { | |
| return getRuleContext(OptgroupTagStartContext.class,i); | |
| } | |
| public List<RbTagStartContext> rbTagStart() { | |
| return getRuleContexts(RbTagStartContext.class); | |
| } | |
| public RbTagStartContext rbTagStart(int i) { | |
| return getRuleContext(RbTagStartContext.class,i); | |
| } | |
| public List<RtTagStartContext> rtTagStart() { | |
| return getRuleContexts(RtTagStartContext.class); | |
| } | |
| public RtTagStartContext rtTagStart(int i) { | |
| return getRuleContext(RtTagStartContext.class,i); | |
| } | |
| public List<RtcTagStartContext> rtcTagStart() { | |
| return getRuleContexts(RtcTagStartContext.class); | |
| } | |
| public RtcTagStartContext rtcTagStart(int i) { | |
| return getRuleContext(RtcTagStartContext.class,i); | |
| } | |
| public List<RpTagStartContext> rpTagStart() { | |
| return getRuleContexts(RpTagStartContext.class); | |
| } | |
| public RpTagStartContext rpTagStart(int i) { | |
| return getRuleContext(RpTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public DtContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_dt; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDt(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final DtContext dt() throws RecognitionException { | |
| DtContext _localctx = new DtContext(_ctx, getState()); | |
| enterRule(_localctx, 64, RULE_dt); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(990); | |
| dtTagStart(false); | |
| setState(1039); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,58,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(1037); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) { | |
| case 1: | |
| { | |
| setState(991); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(992); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(993); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(994); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(995); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(996); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(997); | |
| th(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(998); | |
| body(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(999); | |
| colgroup(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(1000); | |
| dd(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(1001); | |
| head(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(1002); | |
| html(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(1003); | |
| option(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(1004); | |
| tbody(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(1005); | |
| thead(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(1006); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(1007); | |
| optgroup(); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(1008); | |
| rb(); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(1009); | |
| rt(); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(1010); | |
| rtc(); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(1011); | |
| rp(); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(1012); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(1013); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(1014); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(1015); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(1016); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(1017); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(1018); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(1019); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(1020); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| setState(1021); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(1022); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(1023); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(1024); | |
| theadTagStart(true); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(1025); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 36: | |
| { | |
| setState(1026); | |
| optgroupTagStart(true); | |
| } | |
| break; | |
| case 37: | |
| { | |
| setState(1027); | |
| rbTagStart(true); | |
| } | |
| break; | |
| case 38: | |
| { | |
| setState(1028); | |
| rtTagStart(true); | |
| } | |
| break; | |
| case 39: | |
| { | |
| setState(1029); | |
| rtcTagStart(true); | |
| } | |
| break; | |
| case 40: | |
| { | |
| setState(1030); | |
| rpTagStart(true); | |
| } | |
| break; | |
| case 41: | |
| { | |
| { | |
| setState(1031); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(1032); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 42: | |
| { | |
| setState(1033); | |
| htmlComment(); | |
| } | |
| break; | |
| case 43: | |
| { | |
| setState(1034); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 44: | |
| { | |
| setState(1035); | |
| text(); | |
| } | |
| break; | |
| case 45: | |
| { | |
| setState(1036); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(1041); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,58,_ctx); | |
| } | |
| setState(1042); | |
| dtTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class HeadTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public HeadTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public HeadTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_headTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final HeadTagStartContext headTagStart(boolean isNonTight) throws RecognitionException { | |
| HeadTagStartContext _localctx = new HeadTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 66, RULE_headTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1044); | |
| match(START); | |
| setState(1045); | |
| match(HEAD_HTML_TAG_NAME); | |
| setState(1052); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1050); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1046); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1047); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1048); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1049); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1054); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1055); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class HeadTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public HeadTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_headTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHeadTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final HeadTagEndContext headTagEnd() throws RecognitionException { | |
| HeadTagEndContext _localctx = new HeadTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 68, RULE_headTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1057); | |
| match(START); | |
| setState(1058); | |
| match(SLASH); | |
| setState(1059); | |
| match(HEAD_HTML_TAG_NAME); | |
| setState(1063); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(1060); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(1065); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1066); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class HeadContext extends ParserRuleContext { | |
| public HeadTagStartContext headTagStart() { | |
| return getRuleContext(HeadTagStartContext.class,0); | |
| } | |
| public HeadTagEndContext headTagEnd() { | |
| return getRuleContext(HeadTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TheadContext> thead() { | |
| return getRuleContexts(TheadContext.class); | |
| } | |
| public TheadContext thead(int i) { | |
| return getRuleContext(TheadContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<OptgroupContext> optgroup() { | |
| return getRuleContexts(OptgroupContext.class); | |
| } | |
| public OptgroupContext optgroup(int i) { | |
| return getRuleContext(OptgroupContext.class,i); | |
| } | |
| public List<RbContext> rb() { | |
| return getRuleContexts(RbContext.class); | |
| } | |
| public RbContext rb(int i) { | |
| return getRuleContext(RbContext.class,i); | |
| } | |
| public List<RtContext> rt() { | |
| return getRuleContexts(RtContext.class); | |
| } | |
| public RtContext rt(int i) { | |
| return getRuleContext(RtContext.class,i); | |
| } | |
| public List<RtcContext> rtc() { | |
| return getRuleContexts(RtcContext.class); | |
| } | |
| public RtcContext rtc(int i) { | |
| return getRuleContext(RtcContext.class,i); | |
| } | |
| public List<RpContext> rp() { | |
| return getRuleContexts(RpContext.class); | |
| } | |
| public RpContext rp(int i) { | |
| return getRuleContext(RpContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TheadTagStartContext> theadTagStart() { | |
| return getRuleContexts(TheadTagStartContext.class); | |
| } | |
| public TheadTagStartContext theadTagStart(int i) { | |
| return getRuleContext(TheadTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<OptgroupTagStartContext> optgroupTagStart() { | |
| return getRuleContexts(OptgroupTagStartContext.class); | |
| } | |
| public OptgroupTagStartContext optgroupTagStart(int i) { | |
| return getRuleContext(OptgroupTagStartContext.class,i); | |
| } | |
| public List<RbTagStartContext> rbTagStart() { | |
| return getRuleContexts(RbTagStartContext.class); | |
| } | |
| public RbTagStartContext rbTagStart(int i) { | |
| return getRuleContext(RbTagStartContext.class,i); | |
| } | |
| public List<RtTagStartContext> rtTagStart() { | |
| return getRuleContexts(RtTagStartContext.class); | |
| } | |
| public RtTagStartContext rtTagStart(int i) { | |
| return getRuleContext(RtTagStartContext.class,i); | |
| } | |
| public List<RtcTagStartContext> rtcTagStart() { | |
| return getRuleContexts(RtcTagStartContext.class); | |
| } | |
| public RtcTagStartContext rtcTagStart(int i) { | |
| return getRuleContext(RtcTagStartContext.class,i); | |
| } | |
| public List<RpTagStartContext> rpTagStart() { | |
| return getRuleContexts(RpTagStartContext.class); | |
| } | |
| public RpTagStartContext rpTagStart(int i) { | |
| return getRuleContext(RpTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public HeadContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_head; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHead(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final HeadContext head() throws RecognitionException { | |
| HeadContext _localctx = new HeadContext(_ctx, getState()); | |
| enterRule(_localctx, 70, RULE_head); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1068); | |
| headTagStart(false); | |
| setState(1117); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,63,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(1115); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1069); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(1070); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(1071); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(1072); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(1073); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(1074); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(1075); | |
| th(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(1076); | |
| body(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(1077); | |
| colgroup(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(1078); | |
| dd(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(1079); | |
| dt(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(1080); | |
| html(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(1081); | |
| option(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(1082); | |
| tbody(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(1083); | |
| thead(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(1084); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(1085); | |
| optgroup(); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(1086); | |
| rb(); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(1087); | |
| rt(); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(1088); | |
| rtc(); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(1089); | |
| rp(); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(1090); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(1091); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(1092); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(1093); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(1094); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(1095); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(1096); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(1097); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(1098); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| setState(1099); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(1100); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(1101); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(1102); | |
| theadTagStart(true); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(1103); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 36: | |
| { | |
| setState(1104); | |
| optgroupTagStart(true); | |
| } | |
| break; | |
| case 37: | |
| { | |
| setState(1105); | |
| rbTagStart(true); | |
| } | |
| break; | |
| case 38: | |
| { | |
| setState(1106); | |
| rtTagStart(true); | |
| } | |
| break; | |
| case 39: | |
| { | |
| setState(1107); | |
| rtcTagStart(true); | |
| } | |
| break; | |
| case 40: | |
| { | |
| setState(1108); | |
| rpTagStart(true); | |
| } | |
| break; | |
| case 41: | |
| { | |
| { | |
| setState(1109); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(1110); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 42: | |
| { | |
| setState(1111); | |
| htmlComment(); | |
| } | |
| break; | |
| case 43: | |
| { | |
| setState(1112); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 44: | |
| { | |
| setState(1113); | |
| text(); | |
| } | |
| break; | |
| case 45: | |
| { | |
| setState(1114); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(1119); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,63,_ctx); | |
| } | |
| setState(1120); | |
| headTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class HtmlTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public HtmlTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public HtmlTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_htmlTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final HtmlTagStartContext htmlTagStart(boolean isNonTight) throws RecognitionException { | |
| HtmlTagStartContext _localctx = new HtmlTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 72, RULE_htmlTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1122); | |
| match(START); | |
| setState(1123); | |
| match(HTML_HTML_TAG_NAME); | |
| setState(1130); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1128); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1124); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1125); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1126); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1127); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1132); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1133); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class HtmlTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public HtmlTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_htmlTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final HtmlTagEndContext htmlTagEnd() throws RecognitionException { | |
| HtmlTagEndContext _localctx = new HtmlTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 74, RULE_htmlTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1135); | |
| match(START); | |
| setState(1136); | |
| match(SLASH); | |
| setState(1137); | |
| match(HTML_HTML_TAG_NAME); | |
| setState(1141); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(1138); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(1143); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1144); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class HtmlContext extends ParserRuleContext { | |
| public HtmlTagStartContext htmlTagStart() { | |
| return getRuleContext(HtmlTagStartContext.class,0); | |
| } | |
| public HtmlTagEndContext htmlTagEnd() { | |
| return getRuleContext(HtmlTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TheadContext> thead() { | |
| return getRuleContexts(TheadContext.class); | |
| } | |
| public TheadContext thead(int i) { | |
| return getRuleContext(TheadContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<OptgroupContext> optgroup() { | |
| return getRuleContexts(OptgroupContext.class); | |
| } | |
| public OptgroupContext optgroup(int i) { | |
| return getRuleContext(OptgroupContext.class,i); | |
| } | |
| public List<RbContext> rb() { | |
| return getRuleContexts(RbContext.class); | |
| } | |
| public RbContext rb(int i) { | |
| return getRuleContext(RbContext.class,i); | |
| } | |
| public List<RtContext> rt() { | |
| return getRuleContexts(RtContext.class); | |
| } | |
| public RtContext rt(int i) { | |
| return getRuleContext(RtContext.class,i); | |
| } | |
| public List<RtcContext> rtc() { | |
| return getRuleContexts(RtcContext.class); | |
| } | |
| public RtcContext rtc(int i) { | |
| return getRuleContext(RtcContext.class,i); | |
| } | |
| public List<RpContext> rp() { | |
| return getRuleContexts(RpContext.class); | |
| } | |
| public RpContext rp(int i) { | |
| return getRuleContext(RpContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TheadTagStartContext> theadTagStart() { | |
| return getRuleContexts(TheadTagStartContext.class); | |
| } | |
| public TheadTagStartContext theadTagStart(int i) { | |
| return getRuleContext(TheadTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<OptgroupTagStartContext> optgroupTagStart() { | |
| return getRuleContexts(OptgroupTagStartContext.class); | |
| } | |
| public OptgroupTagStartContext optgroupTagStart(int i) { | |
| return getRuleContext(OptgroupTagStartContext.class,i); | |
| } | |
| public List<RbTagStartContext> rbTagStart() { | |
| return getRuleContexts(RbTagStartContext.class); | |
| } | |
| public RbTagStartContext rbTagStart(int i) { | |
| return getRuleContext(RbTagStartContext.class,i); | |
| } | |
| public List<RtTagStartContext> rtTagStart() { | |
| return getRuleContexts(RtTagStartContext.class); | |
| } | |
| public RtTagStartContext rtTagStart(int i) { | |
| return getRuleContext(RtTagStartContext.class,i); | |
| } | |
| public List<RtcTagStartContext> rtcTagStart() { | |
| return getRuleContexts(RtcTagStartContext.class); | |
| } | |
| public RtcTagStartContext rtcTagStart(int i) { | |
| return getRuleContext(RtcTagStartContext.class,i); | |
| } | |
| public List<RpTagStartContext> rpTagStart() { | |
| return getRuleContexts(RpTagStartContext.class); | |
| } | |
| public RpTagStartContext rpTagStart(int i) { | |
| return getRuleContext(RpTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public HtmlContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_html; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtml(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final HtmlContext html() throws RecognitionException { | |
| HtmlContext _localctx = new HtmlContext(_ctx, getState()); | |
| enterRule(_localctx, 76, RULE_html); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1146); | |
| htmlTagStart(false); | |
| setState(1195); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,68,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(1193); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1147); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(1148); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(1149); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(1150); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(1151); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(1152); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(1153); | |
| th(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(1154); | |
| body(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(1155); | |
| colgroup(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(1156); | |
| dd(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(1157); | |
| dt(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(1158); | |
| head(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(1159); | |
| option(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(1160); | |
| tbody(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(1161); | |
| thead(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(1162); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(1163); | |
| optgroup(); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(1164); | |
| rb(); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(1165); | |
| rt(); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(1166); | |
| rtc(); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(1167); | |
| rp(); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(1168); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(1169); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(1170); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(1171); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(1172); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(1173); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(1174); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(1175); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(1176); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| setState(1177); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(1178); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(1179); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(1180); | |
| theadTagStart(true); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(1181); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 36: | |
| { | |
| setState(1182); | |
| optgroupTagStart(true); | |
| } | |
| break; | |
| case 37: | |
| { | |
| setState(1183); | |
| rbTagStart(true); | |
| } | |
| break; | |
| case 38: | |
| { | |
| setState(1184); | |
| rtTagStart(true); | |
| } | |
| break; | |
| case 39: | |
| { | |
| setState(1185); | |
| rtcTagStart(true); | |
| } | |
| break; | |
| case 40: | |
| { | |
| setState(1186); | |
| rpTagStart(true); | |
| } | |
| break; | |
| case 41: | |
| { | |
| { | |
| setState(1187); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(1188); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 42: | |
| { | |
| setState(1189); | |
| htmlComment(); | |
| } | |
| break; | |
| case 43: | |
| { | |
| setState(1190); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 44: | |
| { | |
| setState(1191); | |
| text(); | |
| } | |
| break; | |
| case 45: | |
| { | |
| setState(1192); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(1197); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,68,_ctx); | |
| } | |
| setState(1198); | |
| htmlTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class OptionTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public OptionTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public OptionTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_optionTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final OptionTagStartContext optionTagStart(boolean isNonTight) throws RecognitionException { | |
| OptionTagStartContext _localctx = new OptionTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 78, RULE_optionTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1200); | |
| match(START); | |
| setState(1201); | |
| match(OPTION_HTML_TAG_NAME); | |
| setState(1208); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1206); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1202); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1203); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1204); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1205); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1210); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1211); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class OptionTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public OptionTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_optionTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptionTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final OptionTagEndContext optionTagEnd() throws RecognitionException { | |
| OptionTagEndContext _localctx = new OptionTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 80, RULE_optionTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1213); | |
| match(START); | |
| setState(1214); | |
| match(SLASH); | |
| setState(1215); | |
| match(OPTION_HTML_TAG_NAME); | |
| setState(1219); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(1216); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(1221); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1222); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class OptionContext extends ParserRuleContext { | |
| public OptionTagStartContext optionTagStart() { | |
| return getRuleContext(OptionTagStartContext.class,0); | |
| } | |
| public OptionTagEndContext optionTagEnd() { | |
| return getRuleContext(OptionTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TheadContext> thead() { | |
| return getRuleContexts(TheadContext.class); | |
| } | |
| public TheadContext thead(int i) { | |
| return getRuleContext(TheadContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<OptgroupContext> optgroup() { | |
| return getRuleContexts(OptgroupContext.class); | |
| } | |
| public OptgroupContext optgroup(int i) { | |
| return getRuleContext(OptgroupContext.class,i); | |
| } | |
| public List<RbContext> rb() { | |
| return getRuleContexts(RbContext.class); | |
| } | |
| public RbContext rb(int i) { | |
| return getRuleContext(RbContext.class,i); | |
| } | |
| public List<RtContext> rt() { | |
| return getRuleContexts(RtContext.class); | |
| } | |
| public RtContext rt(int i) { | |
| return getRuleContext(RtContext.class,i); | |
| } | |
| public List<RtcContext> rtc() { | |
| return getRuleContexts(RtcContext.class); | |
| } | |
| public RtcContext rtc(int i) { | |
| return getRuleContext(RtcContext.class,i); | |
| } | |
| public List<RpContext> rp() { | |
| return getRuleContexts(RpContext.class); | |
| } | |
| public RpContext rp(int i) { | |
| return getRuleContext(RpContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TheadTagStartContext> theadTagStart() { | |
| return getRuleContexts(TheadTagStartContext.class); | |
| } | |
| public TheadTagStartContext theadTagStart(int i) { | |
| return getRuleContext(TheadTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<OptgroupTagStartContext> optgroupTagStart() { | |
| return getRuleContexts(OptgroupTagStartContext.class); | |
| } | |
| public OptgroupTagStartContext optgroupTagStart(int i) { | |
| return getRuleContext(OptgroupTagStartContext.class,i); | |
| } | |
| public List<RbTagStartContext> rbTagStart() { | |
| return getRuleContexts(RbTagStartContext.class); | |
| } | |
| public RbTagStartContext rbTagStart(int i) { | |
| return getRuleContext(RbTagStartContext.class,i); | |
| } | |
| public List<RtTagStartContext> rtTagStart() { | |
| return getRuleContexts(RtTagStartContext.class); | |
| } | |
| public RtTagStartContext rtTagStart(int i) { | |
| return getRuleContext(RtTagStartContext.class,i); | |
| } | |
| public List<RtcTagStartContext> rtcTagStart() { | |
| return getRuleContexts(RtcTagStartContext.class); | |
| } | |
| public RtcTagStartContext rtcTagStart(int i) { | |
| return getRuleContext(RtcTagStartContext.class,i); | |
| } | |
| public List<RpTagStartContext> rpTagStart() { | |
| return getRuleContexts(RpTagStartContext.class); | |
| } | |
| public RpTagStartContext rpTagStart(int i) { | |
| return getRuleContext(RpTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public OptionContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_option; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOption(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final OptionContext option() throws RecognitionException { | |
| OptionContext _localctx = new OptionContext(_ctx, getState()); | |
| enterRule(_localctx, 82, RULE_option); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1224); | |
| optionTagStart(false); | |
| setState(1273); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,73,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(1271); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,72,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1225); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(1226); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(1227); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(1228); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(1229); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(1230); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(1231); | |
| th(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(1232); | |
| body(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(1233); | |
| colgroup(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(1234); | |
| dd(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(1235); | |
| dt(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(1236); | |
| head(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(1237); | |
| html(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(1238); | |
| tbody(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(1239); | |
| thead(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(1240); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(1241); | |
| optgroup(); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(1242); | |
| rb(); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(1243); | |
| rt(); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(1244); | |
| rtc(); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(1245); | |
| rp(); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(1246); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(1247); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(1248); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(1249); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(1250); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(1251); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(1252); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(1253); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(1254); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| setState(1255); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(1256); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(1257); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(1258); | |
| theadTagStart(true); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(1259); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 36: | |
| { | |
| setState(1260); | |
| optgroupTagStart(true); | |
| } | |
| break; | |
| case 37: | |
| { | |
| setState(1261); | |
| rbTagStart(true); | |
| } | |
| break; | |
| case 38: | |
| { | |
| setState(1262); | |
| rtTagStart(true); | |
| } | |
| break; | |
| case 39: | |
| { | |
| setState(1263); | |
| rtcTagStart(true); | |
| } | |
| break; | |
| case 40: | |
| { | |
| setState(1264); | |
| rpTagStart(true); | |
| } | |
| break; | |
| case 41: | |
| { | |
| { | |
| setState(1265); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(1266); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 42: | |
| { | |
| setState(1267); | |
| htmlComment(); | |
| } | |
| break; | |
| case 43: | |
| { | |
| setState(1268); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 44: | |
| { | |
| setState(1269); | |
| text(); | |
| } | |
| break; | |
| case 45: | |
| { | |
| setState(1270); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(1275); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,73,_ctx); | |
| } | |
| setState(1276); | |
| optionTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TbodyTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public TbodyTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public TbodyTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_tbodyTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TbodyTagStartContext tbodyTagStart(boolean isNonTight) throws RecognitionException { | |
| TbodyTagStartContext _localctx = new TbodyTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 84, RULE_tbodyTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1278); | |
| match(START); | |
| setState(1279); | |
| match(TBODY_HTML_TAG_NAME); | |
| setState(1286); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1284); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1280); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1281); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1282); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1283); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1288); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1289); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TbodyTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public TbodyTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_tbodyTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbodyTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TbodyTagEndContext tbodyTagEnd() throws RecognitionException { | |
| TbodyTagEndContext _localctx = new TbodyTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 86, RULE_tbodyTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1291); | |
| match(START); | |
| setState(1292); | |
| match(SLASH); | |
| setState(1293); | |
| match(TBODY_HTML_TAG_NAME); | |
| setState(1297); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(1294); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(1299); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1300); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TbodyContext extends ParserRuleContext { | |
| public TbodyTagStartContext tbodyTagStart() { | |
| return getRuleContext(TbodyTagStartContext.class,0); | |
| } | |
| public TbodyTagEndContext tbodyTagEnd() { | |
| return getRuleContext(TbodyTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TheadContext> thead() { | |
| return getRuleContexts(TheadContext.class); | |
| } | |
| public TheadContext thead(int i) { | |
| return getRuleContext(TheadContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<OptgroupContext> optgroup() { | |
| return getRuleContexts(OptgroupContext.class); | |
| } | |
| public OptgroupContext optgroup(int i) { | |
| return getRuleContext(OptgroupContext.class,i); | |
| } | |
| public List<RbContext> rb() { | |
| return getRuleContexts(RbContext.class); | |
| } | |
| public RbContext rb(int i) { | |
| return getRuleContext(RbContext.class,i); | |
| } | |
| public List<RtContext> rt() { | |
| return getRuleContexts(RtContext.class); | |
| } | |
| public RtContext rt(int i) { | |
| return getRuleContext(RtContext.class,i); | |
| } | |
| public List<RtcContext> rtc() { | |
| return getRuleContexts(RtcContext.class); | |
| } | |
| public RtcContext rtc(int i) { | |
| return getRuleContext(RtcContext.class,i); | |
| } | |
| public List<RpContext> rp() { | |
| return getRuleContexts(RpContext.class); | |
| } | |
| public RpContext rp(int i) { | |
| return getRuleContext(RpContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TheadTagStartContext> theadTagStart() { | |
| return getRuleContexts(TheadTagStartContext.class); | |
| } | |
| public TheadTagStartContext theadTagStart(int i) { | |
| return getRuleContext(TheadTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<OptgroupTagStartContext> optgroupTagStart() { | |
| return getRuleContexts(OptgroupTagStartContext.class); | |
| } | |
| public OptgroupTagStartContext optgroupTagStart(int i) { | |
| return getRuleContext(OptgroupTagStartContext.class,i); | |
| } | |
| public List<RbTagStartContext> rbTagStart() { | |
| return getRuleContexts(RbTagStartContext.class); | |
| } | |
| public RbTagStartContext rbTagStart(int i) { | |
| return getRuleContext(RbTagStartContext.class,i); | |
| } | |
| public List<RtTagStartContext> rtTagStart() { | |
| return getRuleContexts(RtTagStartContext.class); | |
| } | |
| public RtTagStartContext rtTagStart(int i) { | |
| return getRuleContext(RtTagStartContext.class,i); | |
| } | |
| public List<RtcTagStartContext> rtcTagStart() { | |
| return getRuleContexts(RtcTagStartContext.class); | |
| } | |
| public RtcTagStartContext rtcTagStart(int i) { | |
| return getRuleContext(RtcTagStartContext.class,i); | |
| } | |
| public List<RpTagStartContext> rpTagStart() { | |
| return getRuleContexts(RpTagStartContext.class); | |
| } | |
| public RpTagStartContext rpTagStart(int i) { | |
| return getRuleContext(RpTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public TbodyContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_tbody; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTbody(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TbodyContext tbody() throws RecognitionException { | |
| TbodyContext _localctx = new TbodyContext(_ctx, getState()); | |
| enterRule(_localctx, 88, RULE_tbody); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1302); | |
| tbodyTagStart(false); | |
| setState(1351); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,78,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(1349); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1303); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(1304); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(1305); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(1306); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(1307); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(1308); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(1309); | |
| th(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(1310); | |
| body(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(1311); | |
| colgroup(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(1312); | |
| dd(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(1313); | |
| dt(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(1314); | |
| head(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(1315); | |
| html(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(1316); | |
| option(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(1317); | |
| thead(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(1318); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(1319); | |
| optgroup(); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(1320); | |
| rb(); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(1321); | |
| rt(); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(1322); | |
| rtc(); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(1323); | |
| rp(); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(1324); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(1325); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(1326); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(1327); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(1328); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(1329); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(1330); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(1331); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(1332); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| setState(1333); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(1334); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(1335); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(1336); | |
| theadTagStart(true); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(1337); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 36: | |
| { | |
| setState(1338); | |
| optgroupTagStart(true); | |
| } | |
| break; | |
| case 37: | |
| { | |
| setState(1339); | |
| rbTagStart(true); | |
| } | |
| break; | |
| case 38: | |
| { | |
| setState(1340); | |
| rtTagStart(true); | |
| } | |
| break; | |
| case 39: | |
| { | |
| setState(1341); | |
| rtcTagStart(true); | |
| } | |
| break; | |
| case 40: | |
| { | |
| setState(1342); | |
| rpTagStart(true); | |
| } | |
| break; | |
| case 41: | |
| { | |
| { | |
| setState(1343); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(1344); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 42: | |
| { | |
| setState(1345); | |
| htmlComment(); | |
| } | |
| break; | |
| case 43: | |
| { | |
| setState(1346); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 44: | |
| { | |
| setState(1347); | |
| text(); | |
| } | |
| break; | |
| case 45: | |
| { | |
| setState(1348); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(1353); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,78,_ctx); | |
| } | |
| setState(1354); | |
| tbodyTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TfootTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public TfootTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public TfootTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_tfootTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TfootTagStartContext tfootTagStart(boolean isNonTight) throws RecognitionException { | |
| TfootTagStartContext _localctx = new TfootTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 90, RULE_tfootTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1356); | |
| match(START); | |
| setState(1357); | |
| match(TFOOT_HTML_TAG_NAME); | |
| setState(1364); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1362); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1358); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1359); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1360); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1361); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1366); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1367); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TfootTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public TfootTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_tfootTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfootTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TfootTagEndContext tfootTagEnd() throws RecognitionException { | |
| TfootTagEndContext _localctx = new TfootTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 92, RULE_tfootTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1369); | |
| match(START); | |
| setState(1370); | |
| match(SLASH); | |
| setState(1371); | |
| match(TFOOT_HTML_TAG_NAME); | |
| setState(1375); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(1372); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(1377); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1378); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TfootContext extends ParserRuleContext { | |
| public TfootTagStartContext tfootTagStart() { | |
| return getRuleContext(TfootTagStartContext.class,0); | |
| } | |
| public TfootTagEndContext tfootTagEnd() { | |
| return getRuleContext(TfootTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TheadContext> thead() { | |
| return getRuleContexts(TheadContext.class); | |
| } | |
| public TheadContext thead(int i) { | |
| return getRuleContext(TheadContext.class,i); | |
| } | |
| public List<OptgroupContext> optgroup() { | |
| return getRuleContexts(OptgroupContext.class); | |
| } | |
| public OptgroupContext optgroup(int i) { | |
| return getRuleContext(OptgroupContext.class,i); | |
| } | |
| public List<RbContext> rb() { | |
| return getRuleContexts(RbContext.class); | |
| } | |
| public RbContext rb(int i) { | |
| return getRuleContext(RbContext.class,i); | |
| } | |
| public List<RtContext> rt() { | |
| return getRuleContexts(RtContext.class); | |
| } | |
| public RtContext rt(int i) { | |
| return getRuleContext(RtContext.class,i); | |
| } | |
| public List<RtcContext> rtc() { | |
| return getRuleContexts(RtcContext.class); | |
| } | |
| public RtcContext rtc(int i) { | |
| return getRuleContext(RtcContext.class,i); | |
| } | |
| public List<RpContext> rp() { | |
| return getRuleContexts(RpContext.class); | |
| } | |
| public RpContext rp(int i) { | |
| return getRuleContext(RpContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TheadTagStartContext> theadTagStart() { | |
| return getRuleContexts(TheadTagStartContext.class); | |
| } | |
| public TheadTagStartContext theadTagStart(int i) { | |
| return getRuleContext(TheadTagStartContext.class,i); | |
| } | |
| public List<OptgroupTagStartContext> optgroupTagStart() { | |
| return getRuleContexts(OptgroupTagStartContext.class); | |
| } | |
| public OptgroupTagStartContext optgroupTagStart(int i) { | |
| return getRuleContext(OptgroupTagStartContext.class,i); | |
| } | |
| public List<RbTagStartContext> rbTagStart() { | |
| return getRuleContexts(RbTagStartContext.class); | |
| } | |
| public RbTagStartContext rbTagStart(int i) { | |
| return getRuleContext(RbTagStartContext.class,i); | |
| } | |
| public List<RtTagStartContext> rtTagStart() { | |
| return getRuleContexts(RtTagStartContext.class); | |
| } | |
| public RtTagStartContext rtTagStart(int i) { | |
| return getRuleContext(RtTagStartContext.class,i); | |
| } | |
| public List<RtcTagStartContext> rtcTagStart() { | |
| return getRuleContexts(RtcTagStartContext.class); | |
| } | |
| public RtcTagStartContext rtcTagStart(int i) { | |
| return getRuleContext(RtcTagStartContext.class,i); | |
| } | |
| public List<RpTagStartContext> rpTagStart() { | |
| return getRuleContexts(RpTagStartContext.class); | |
| } | |
| public RpTagStartContext rpTagStart(int i) { | |
| return getRuleContext(RpTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public TfootContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_tfoot; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTfoot(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TfootContext tfoot() throws RecognitionException { | |
| TfootContext _localctx = new TfootContext(_ctx, getState()); | |
| enterRule(_localctx, 94, RULE_tfoot); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1380); | |
| tfootTagStart(false); | |
| setState(1429); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,83,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(1427); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1381); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(1382); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(1383); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(1384); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(1385); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(1386); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(1387); | |
| th(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(1388); | |
| body(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(1389); | |
| colgroup(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(1390); | |
| dd(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(1391); | |
| dt(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(1392); | |
| head(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(1393); | |
| html(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(1394); | |
| option(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(1395); | |
| tbody(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(1396); | |
| thead(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(1397); | |
| optgroup(); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(1398); | |
| rb(); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(1399); | |
| rt(); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(1400); | |
| rtc(); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(1401); | |
| rp(); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(1402); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(1403); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(1404); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(1405); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(1406); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(1407); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(1408); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(1409); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(1410); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| setState(1411); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(1412); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(1413); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(1414); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(1415); | |
| theadTagStart(true); | |
| } | |
| break; | |
| case 36: | |
| { | |
| setState(1416); | |
| optgroupTagStart(true); | |
| } | |
| break; | |
| case 37: | |
| { | |
| setState(1417); | |
| rbTagStart(true); | |
| } | |
| break; | |
| case 38: | |
| { | |
| setState(1418); | |
| rtTagStart(true); | |
| } | |
| break; | |
| case 39: | |
| { | |
| setState(1419); | |
| rtcTagStart(true); | |
| } | |
| break; | |
| case 40: | |
| { | |
| setState(1420); | |
| rpTagStart(true); | |
| } | |
| break; | |
| case 41: | |
| { | |
| { | |
| setState(1421); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(1422); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 42: | |
| { | |
| setState(1423); | |
| htmlComment(); | |
| } | |
| break; | |
| case 43: | |
| { | |
| setState(1424); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 44: | |
| { | |
| setState(1425); | |
| text(); | |
| } | |
| break; | |
| case 45: | |
| { | |
| setState(1426); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(1431); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,83,_ctx); | |
| } | |
| setState(1432); | |
| tfootTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TheadTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public TheadTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public TheadTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_theadTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TheadTagStartContext theadTagStart(boolean isNonTight) throws RecognitionException { | |
| TheadTagStartContext _localctx = new TheadTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 96, RULE_theadTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1434); | |
| match(START); | |
| setState(1435); | |
| match(THEAD_HTML_TAG_NAME); | |
| setState(1442); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1440); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1436); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1437); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1438); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1439); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1444); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1445); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TheadTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public TheadTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_theadTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTheadTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TheadTagEndContext theadTagEnd() throws RecognitionException { | |
| TheadTagEndContext _localctx = new TheadTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 98, RULE_theadTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1447); | |
| match(START); | |
| setState(1448); | |
| match(SLASH); | |
| setState(1449); | |
| match(THEAD_HTML_TAG_NAME); | |
| setState(1453); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(1450); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(1455); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1456); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TheadContext extends ParserRuleContext { | |
| public TheadTagStartContext theadTagStart() { | |
| return getRuleContext(TheadTagStartContext.class,0); | |
| } | |
| public TheadTagEndContext theadTagEnd() { | |
| return getRuleContext(TheadTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<OptgroupContext> optgroup() { | |
| return getRuleContexts(OptgroupContext.class); | |
| } | |
| public OptgroupContext optgroup(int i) { | |
| return getRuleContext(OptgroupContext.class,i); | |
| } | |
| public List<RbContext> rb() { | |
| return getRuleContexts(RbContext.class); | |
| } | |
| public RbContext rb(int i) { | |
| return getRuleContext(RbContext.class,i); | |
| } | |
| public List<RtContext> rt() { | |
| return getRuleContexts(RtContext.class); | |
| } | |
| public RtContext rt(int i) { | |
| return getRuleContext(RtContext.class,i); | |
| } | |
| public List<RtcContext> rtc() { | |
| return getRuleContexts(RtcContext.class); | |
| } | |
| public RtcContext rtc(int i) { | |
| return getRuleContext(RtcContext.class,i); | |
| } | |
| public List<RpContext> rp() { | |
| return getRuleContexts(RpContext.class); | |
| } | |
| public RpContext rp(int i) { | |
| return getRuleContext(RpContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<OptgroupTagStartContext> optgroupTagStart() { | |
| return getRuleContexts(OptgroupTagStartContext.class); | |
| } | |
| public OptgroupTagStartContext optgroupTagStart(int i) { | |
| return getRuleContext(OptgroupTagStartContext.class,i); | |
| } | |
| public List<RbTagStartContext> rbTagStart() { | |
| return getRuleContexts(RbTagStartContext.class); | |
| } | |
| public RbTagStartContext rbTagStart(int i) { | |
| return getRuleContext(RbTagStartContext.class,i); | |
| } | |
| public List<RtTagStartContext> rtTagStart() { | |
| return getRuleContexts(RtTagStartContext.class); | |
| } | |
| public RtTagStartContext rtTagStart(int i) { | |
| return getRuleContext(RtTagStartContext.class,i); | |
| } | |
| public List<RtcTagStartContext> rtcTagStart() { | |
| return getRuleContexts(RtcTagStartContext.class); | |
| } | |
| public RtcTagStartContext rtcTagStart(int i) { | |
| return getRuleContext(RtcTagStartContext.class,i); | |
| } | |
| public List<RpTagStartContext> rpTagStart() { | |
| return getRuleContexts(RpTagStartContext.class); | |
| } | |
| public RpTagStartContext rpTagStart(int i) { | |
| return getRuleContext(RpTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public TheadContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_thead; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitThead(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TheadContext thead() throws RecognitionException { | |
| TheadContext _localctx = new TheadContext(_ctx, getState()); | |
| enterRule(_localctx, 100, RULE_thead); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1458); | |
| theadTagStart(false); | |
| setState(1507); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,88,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(1505); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1459); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(1460); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(1461); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(1462); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(1463); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(1464); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(1465); | |
| th(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(1466); | |
| body(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(1467); | |
| colgroup(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(1468); | |
| dd(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(1469); | |
| dt(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(1470); | |
| head(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(1471); | |
| html(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(1472); | |
| option(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(1473); | |
| tbody(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(1474); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(1475); | |
| optgroup(); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(1476); | |
| rb(); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(1477); | |
| rt(); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(1478); | |
| rtc(); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(1479); | |
| rp(); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(1480); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(1481); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(1482); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(1483); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(1484); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(1485); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(1486); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(1487); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(1488); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| setState(1489); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(1490); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(1491); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(1492); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(1493); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 36: | |
| { | |
| setState(1494); | |
| optgroupTagStart(true); | |
| } | |
| break; | |
| case 37: | |
| { | |
| setState(1495); | |
| rbTagStart(true); | |
| } | |
| break; | |
| case 38: | |
| { | |
| setState(1496); | |
| rtTagStart(true); | |
| } | |
| break; | |
| case 39: | |
| { | |
| setState(1497); | |
| rtcTagStart(true); | |
| } | |
| break; | |
| case 40: | |
| { | |
| setState(1498); | |
| rpTagStart(true); | |
| } | |
| break; | |
| case 41: | |
| { | |
| { | |
| setState(1499); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(1500); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 42: | |
| { | |
| setState(1501); | |
| htmlComment(); | |
| } | |
| break; | |
| case 43: | |
| { | |
| setState(1502); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 44: | |
| { | |
| setState(1503); | |
| text(); | |
| } | |
| break; | |
| case 45: | |
| { | |
| setState(1504); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(1509); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,88,_ctx); | |
| } | |
| setState(1510); | |
| theadTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class SingletonElementContext extends ParserRuleContext { | |
| public EmptyTagContext emptyTag() { | |
| return getRuleContext(EmptyTagContext.class,0); | |
| } | |
| public AreaTagContext areaTag() { | |
| return getRuleContext(AreaTagContext.class,0); | |
| } | |
| public BaseTagContext baseTag() { | |
| return getRuleContext(BaseTagContext.class,0); | |
| } | |
| public BasefontTagContext basefontTag() { | |
| return getRuleContext(BasefontTagContext.class,0); | |
| } | |
| public BrTagContext brTag() { | |
| return getRuleContext(BrTagContext.class,0); | |
| } | |
| public ColTagContext colTag() { | |
| return getRuleContext(ColTagContext.class,0); | |
| } | |
| public FrameTagContext frameTag() { | |
| return getRuleContext(FrameTagContext.class,0); | |
| } | |
| public HrTagContext hrTag() { | |
| return getRuleContext(HrTagContext.class,0); | |
| } | |
| public ImgTagContext imgTag() { | |
| return getRuleContext(ImgTagContext.class,0); | |
| } | |
| public InputTagContext inputTag() { | |
| return getRuleContext(InputTagContext.class,0); | |
| } | |
| public IsindexTagContext isindexTag() { | |
| return getRuleContext(IsindexTagContext.class,0); | |
| } | |
| public LinkTagContext linkTag() { | |
| return getRuleContext(LinkTagContext.class,0); | |
| } | |
| public MetaTagContext metaTag() { | |
| return getRuleContext(MetaTagContext.class,0); | |
| } | |
| public ParamTagContext paramTag() { | |
| return getRuleContext(ParamTagContext.class,0); | |
| } | |
| public EmbedTagContext embedTag() { | |
| return getRuleContext(EmbedTagContext.class,0); | |
| } | |
| public KeygenTagContext keygenTag() { | |
| return getRuleContext(KeygenTagContext.class,0); | |
| } | |
| public SourceTagContext sourceTag() { | |
| return getRuleContext(SourceTagContext.class,0); | |
| } | |
| public TrackTagContext trackTag() { | |
| return getRuleContext(TrackTagContext.class,0); | |
| } | |
| public WbrTagContext wbrTag() { | |
| return getRuleContext(WbrTagContext.class,0); | |
| } | |
| public WrongSingletonTagContext wrongSingletonTag() { | |
| return getRuleContext(WrongSingletonTagContext.class,0); | |
| } | |
| public SingletonElementContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_singletonElement; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonElement(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final SingletonElementContext singletonElement() throws RecognitionException { | |
| SingletonElementContext _localctx = new SingletonElementContext(_ctx, getState()); | |
| enterRule(_localctx, 102, RULE_singletonElement); | |
| try { | |
| setState(1532); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) { | |
| case 1: | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1512); | |
| emptyTag(); | |
| } | |
| break; | |
| case 2: | |
| enterOuterAlt(_localctx, 2); | |
| { | |
| setState(1513); | |
| areaTag(); | |
| } | |
| break; | |
| case 3: | |
| enterOuterAlt(_localctx, 3); | |
| { | |
| setState(1514); | |
| baseTag(); | |
| } | |
| break; | |
| case 4: | |
| enterOuterAlt(_localctx, 4); | |
| { | |
| setState(1515); | |
| basefontTag(); | |
| } | |
| break; | |
| case 5: | |
| enterOuterAlt(_localctx, 5); | |
| { | |
| setState(1516); | |
| brTag(); | |
| } | |
| break; | |
| case 6: | |
| enterOuterAlt(_localctx, 6); | |
| { | |
| setState(1517); | |
| colTag(); | |
| } | |
| break; | |
| case 7: | |
| enterOuterAlt(_localctx, 7); | |
| { | |
| setState(1518); | |
| frameTag(); | |
| } | |
| break; | |
| case 8: | |
| enterOuterAlt(_localctx, 8); | |
| { | |
| setState(1519); | |
| hrTag(); | |
| } | |
| break; | |
| case 9: | |
| enterOuterAlt(_localctx, 9); | |
| { | |
| setState(1520); | |
| imgTag(); | |
| } | |
| break; | |
| case 10: | |
| enterOuterAlt(_localctx, 10); | |
| { | |
| setState(1521); | |
| inputTag(); | |
| } | |
| break; | |
| case 11: | |
| enterOuterAlt(_localctx, 11); | |
| { | |
| setState(1522); | |
| isindexTag(); | |
| } | |
| break; | |
| case 12: | |
| enterOuterAlt(_localctx, 12); | |
| { | |
| setState(1523); | |
| linkTag(); | |
| } | |
| break; | |
| case 13: | |
| enterOuterAlt(_localctx, 13); | |
| { | |
| setState(1524); | |
| metaTag(); | |
| } | |
| break; | |
| case 14: | |
| enterOuterAlt(_localctx, 14); | |
| { | |
| setState(1525); | |
| paramTag(); | |
| } | |
| break; | |
| case 15: | |
| enterOuterAlt(_localctx, 15); | |
| { | |
| setState(1526); | |
| embedTag(); | |
| } | |
| break; | |
| case 16: | |
| enterOuterAlt(_localctx, 16); | |
| { | |
| setState(1527); | |
| keygenTag(); | |
| } | |
| break; | |
| case 17: | |
| enterOuterAlt(_localctx, 17); | |
| { | |
| setState(1528); | |
| sourceTag(); | |
| } | |
| break; | |
| case 18: | |
| enterOuterAlt(_localctx, 18); | |
| { | |
| setState(1529); | |
| trackTag(); | |
| } | |
| break; | |
| case 19: | |
| enterOuterAlt(_localctx, 19); | |
| { | |
| setState(1530); | |
| wbrTag(); | |
| } | |
| break; | |
| case 20: | |
| enterOuterAlt(_localctx, 20); | |
| { | |
| setState(1531); | |
| wrongSingletonTag(); | |
| } | |
| break; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class EmptyTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode HTML_TAG_NAME() { return getToken(JavadocParser.HTML_TAG_NAME, 0); } | |
| public TerminalNode P_HTML_TAG_NAME() { return getToken(JavadocParser.P_HTML_TAG_NAME, 0); } | |
| public TerminalNode LI_HTML_TAG_NAME() { return getToken(JavadocParser.LI_HTML_TAG_NAME, 0); } | |
| public TerminalNode TR_HTML_TAG_NAME() { return getToken(JavadocParser.TR_HTML_TAG_NAME, 0); } | |
| public TerminalNode TD_HTML_TAG_NAME() { return getToken(JavadocParser.TD_HTML_TAG_NAME, 0); } | |
| public TerminalNode TH_HTML_TAG_NAME() { return getToken(JavadocParser.TH_HTML_TAG_NAME, 0); } | |
| public TerminalNode BODY_HTML_TAG_NAME() { return getToken(JavadocParser.BODY_HTML_TAG_NAME, 0); } | |
| public TerminalNode COLGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.COLGROUP_HTML_TAG_NAME, 0); } | |
| public TerminalNode DD_HTML_TAG_NAME() { return getToken(JavadocParser.DD_HTML_TAG_NAME, 0); } | |
| public TerminalNode DT_HTML_TAG_NAME() { return getToken(JavadocParser.DT_HTML_TAG_NAME, 0); } | |
| public TerminalNode HEAD_HTML_TAG_NAME() { return getToken(JavadocParser.HEAD_HTML_TAG_NAME, 0); } | |
| public TerminalNode HTML_HTML_TAG_NAME() { return getToken(JavadocParser.HTML_HTML_TAG_NAME, 0); } | |
| public TerminalNode OPTION_HTML_TAG_NAME() { return getToken(JavadocParser.OPTION_HTML_TAG_NAME, 0); } | |
| public TerminalNode TBODY_HTML_TAG_NAME() { return getToken(JavadocParser.TBODY_HTML_TAG_NAME, 0); } | |
| public TerminalNode TFOOT_HTML_TAG_NAME() { return getToken(JavadocParser.TFOOT_HTML_TAG_NAME, 0); } | |
| public TerminalNode THEAD_HTML_TAG_NAME() { return getToken(JavadocParser.THEAD_HTML_TAG_NAME, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public EmptyTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_emptyTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitEmptyTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final EmptyTagContext emptyTag() throws RecognitionException { | |
| EmptyTagContext _localctx = new EmptyTagContext(_ctx, getState()); | |
| enterRule(_localctx, 104, RULE_emptyTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1534); | |
| match(START); | |
| setState(1535); | |
| _la = _input.LA(1); | |
| 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)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| setState(1542); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1540); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1536); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1537); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1538); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1539); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1544); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1545); | |
| match(SLASH_END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class AreaTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public AreaTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_areaTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitAreaTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final AreaTagContext areaTag() throws RecognitionException { | |
| AreaTagContext _localctx = new AreaTagContext(_ctx, getState()); | |
| enterRule(_localctx, 106, RULE_areaTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1547); | |
| match(START); | |
| setState(1548); | |
| match(AREA_HTML_TAG_NAME); | |
| setState(1555); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1553); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1549); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1550); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1551); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1552); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1557); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1558); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class BaseTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public BaseTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_baseTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBaseTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final BaseTagContext baseTag() throws RecognitionException { | |
| BaseTagContext _localctx = new BaseTagContext(_ctx, getState()); | |
| enterRule(_localctx, 108, RULE_baseTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1560); | |
| match(START); | |
| setState(1561); | |
| match(BASE_HTML_TAG_NAME); | |
| setState(1568); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1566); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1562); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1563); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1564); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1565); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1570); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1571); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class BasefontTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public BasefontTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_basefontTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBasefontTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final BasefontTagContext basefontTag() throws RecognitionException { | |
| BasefontTagContext _localctx = new BasefontTagContext(_ctx, getState()); | |
| enterRule(_localctx, 110, RULE_basefontTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1573); | |
| match(START); | |
| setState(1574); | |
| match(BASEFONT_HTML_TAG_NAME); | |
| setState(1581); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1579); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1575); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1576); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1577); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1578); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1583); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1584); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class BrTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public BrTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_brTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitBrTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final BrTagContext brTag() throws RecognitionException { | |
| BrTagContext _localctx = new BrTagContext(_ctx, getState()); | |
| enterRule(_localctx, 112, RULE_brTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1586); | |
| match(START); | |
| setState(1587); | |
| match(BR_HTML_TAG_NAME); | |
| setState(1594); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1592); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1588); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1589); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1590); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1591); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1596); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1597); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class ColTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public ColTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_colTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitColTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final ColTagContext colTag() throws RecognitionException { | |
| ColTagContext _localctx = new ColTagContext(_ctx, getState()); | |
| enterRule(_localctx, 114, RULE_colTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1599); | |
| match(START); | |
| setState(1600); | |
| match(COL_HTML_TAG_NAME); | |
| setState(1607); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1605); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1601); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1602); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1603); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1604); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1609); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1610); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class FrameTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public FrameTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_frameTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitFrameTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final FrameTagContext frameTag() throws RecognitionException { | |
| FrameTagContext _localctx = new FrameTagContext(_ctx, getState()); | |
| enterRule(_localctx, 116, RULE_frameTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1612); | |
| match(START); | |
| setState(1613); | |
| match(FRAME_HTML_TAG_NAME); | |
| setState(1620); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1618); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1614); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1615); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1616); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1617); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1622); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1623); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class HrTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public HrTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_hrTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHrTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final HrTagContext hrTag() throws RecognitionException { | |
| HrTagContext _localctx = new HrTagContext(_ctx, getState()); | |
| enterRule(_localctx, 118, RULE_hrTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1625); | |
| match(START); | |
| setState(1626); | |
| match(HR_HTML_TAG_NAME); | |
| setState(1633); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1631); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1627); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1628); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1629); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1630); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1635); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1636); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class ImgTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public ImgTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_imgTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitImgTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final ImgTagContext imgTag() throws RecognitionException { | |
| ImgTagContext _localctx = new ImgTagContext(_ctx, getState()); | |
| enterRule(_localctx, 120, RULE_imgTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1638); | |
| match(START); | |
| setState(1639); | |
| match(IMG_HTML_TAG_NAME); | |
| setState(1646); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1644); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1640); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1641); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1642); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1643); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1648); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1649); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class InputTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public InputTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_inputTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitInputTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final InputTagContext inputTag() throws RecognitionException { | |
| InputTagContext _localctx = new InputTagContext(_ctx, getState()); | |
| enterRule(_localctx, 122, RULE_inputTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1651); | |
| match(START); | |
| setState(1652); | |
| match(INPUT_HTML_TAG_NAME); | |
| setState(1659); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1657); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1653); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1654); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1655); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1656); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1661); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1662); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class IsindexTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public IsindexTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_isindexTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitIsindexTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final IsindexTagContext isindexTag() throws RecognitionException { | |
| IsindexTagContext _localctx = new IsindexTagContext(_ctx, getState()); | |
| enterRule(_localctx, 124, RULE_isindexTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1664); | |
| match(START); | |
| setState(1665); | |
| match(ISINDEX_HTML_TAG_NAME); | |
| setState(1672); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1670); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1666); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1667); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1668); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1669); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1674); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1675); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class LinkTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public LinkTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_linkTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitLinkTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final LinkTagContext linkTag() throws RecognitionException { | |
| LinkTagContext _localctx = new LinkTagContext(_ctx, getState()); | |
| enterRule(_localctx, 126, RULE_linkTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1677); | |
| match(START); | |
| setState(1678); | |
| match(LINK_HTML_TAG_NAME); | |
| setState(1685); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1683); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1679); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1680); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1681); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1682); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1687); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1688); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class MetaTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public MetaTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_metaTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitMetaTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final MetaTagContext metaTag() throws RecognitionException { | |
| MetaTagContext _localctx = new MetaTagContext(_ctx, getState()); | |
| enterRule(_localctx, 128, RULE_metaTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1690); | |
| match(START); | |
| setState(1691); | |
| match(META_HTML_TAG_NAME); | |
| setState(1698); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1696); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1692); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1693); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1694); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1695); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1700); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1701); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class ParamTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public ParamTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_paramTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParamTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final ParamTagContext paramTag() throws RecognitionException { | |
| ParamTagContext _localctx = new ParamTagContext(_ctx, getState()); | |
| enterRule(_localctx, 130, RULE_paramTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1703); | |
| match(START); | |
| setState(1704); | |
| match(PARAM_HTML_TAG_NAME); | |
| setState(1711); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(1709); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(1705); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(1706); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(1707); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(1708); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(1713); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1714); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class WrongSingletonTagContext extends ParserRuleContext { | |
| public SingletonTagNameContext singletonTagName; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public SingletonTagNameContext singletonTagName() { | |
| return getRuleContext(SingletonTagNameContext.class,0); | |
| } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public WrongSingletonTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_wrongSingletonTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWrongSingletonTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final WrongSingletonTagContext wrongSingletonTag() throws RecognitionException { | |
| WrongSingletonTagContext _localctx = new WrongSingletonTagContext(_ctx, getState()); | |
| enterRule(_localctx, 132, RULE_wrongSingletonTag); | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1716); | |
| match(START); | |
| setState(1717); | |
| match(SLASH); | |
| setState(1718); | |
| ((WrongSingletonTagContext)_localctx).singletonTagName = singletonTagName(); | |
| setState(1719); | |
| match(END); | |
| notifyErrorListeners((((WrongSingletonTagContext)_localctx).singletonTagName!=null?(((WrongSingletonTagContext)_localctx).singletonTagName.start):null), | |
| "javadoc.wrong.singleton.html.tag", null); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class SingletonTagNameContext extends ParserRuleContext { | |
| public TerminalNode AREA_HTML_TAG_NAME() { return getToken(JavadocParser.AREA_HTML_TAG_NAME, 0); } | |
| public TerminalNode BASE_HTML_TAG_NAME() { return getToken(JavadocParser.BASE_HTML_TAG_NAME, 0); } | |
| public TerminalNode BASEFONT_HTML_TAG_NAME() { return getToken(JavadocParser.BASEFONT_HTML_TAG_NAME, 0); } | |
| public TerminalNode BR_HTML_TAG_NAME() { return getToken(JavadocParser.BR_HTML_TAG_NAME, 0); } | |
| public TerminalNode COL_HTML_TAG_NAME() { return getToken(JavadocParser.COL_HTML_TAG_NAME, 0); } | |
| public TerminalNode FRAME_HTML_TAG_NAME() { return getToken(JavadocParser.FRAME_HTML_TAG_NAME, 0); } | |
| public TerminalNode HR_HTML_TAG_NAME() { return getToken(JavadocParser.HR_HTML_TAG_NAME, 0); } | |
| public TerminalNode IMG_HTML_TAG_NAME() { return getToken(JavadocParser.IMG_HTML_TAG_NAME, 0); } | |
| public TerminalNode INPUT_HTML_TAG_NAME() { return getToken(JavadocParser.INPUT_HTML_TAG_NAME, 0); } | |
| public TerminalNode ISINDEX_HTML_TAG_NAME() { return getToken(JavadocParser.ISINDEX_HTML_TAG_NAME, 0); } | |
| public TerminalNode LINK_HTML_TAG_NAME() { return getToken(JavadocParser.LINK_HTML_TAG_NAME, 0); } | |
| public TerminalNode META_HTML_TAG_NAME() { return getToken(JavadocParser.META_HTML_TAG_NAME, 0); } | |
| public TerminalNode PARAM_HTML_TAG_NAME() { return getToken(JavadocParser.PARAM_HTML_TAG_NAME, 0); } | |
| public TerminalNode EMBED_HTML_TAG_NAME() { return getToken(JavadocParser.EMBED_HTML_TAG_NAME, 0); } | |
| public TerminalNode KEYGEN_HTML_TAG_NAME() { return getToken(JavadocParser.KEYGEN_HTML_TAG_NAME, 0); } | |
| public TerminalNode SOURCE_HTML_TAG_NAME() { return getToken(JavadocParser.SOURCE_HTML_TAG_NAME, 0); } | |
| public TerminalNode TRACK_HTML_TAG_NAME() { return getToken(JavadocParser.TRACK_HTML_TAG_NAME, 0); } | |
| public TerminalNode WBR_HTML_TAG_NAME() { return getToken(JavadocParser.WBR_HTML_TAG_NAME, 0); } | |
| public SingletonTagNameContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_singletonTagName; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSingletonTagName(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final SingletonTagNameContext singletonTagName() throws RecognitionException { | |
| SingletonTagNameContext _localctx = new SingletonTagNameContext(_ctx, getState()); | |
| enterRule(_localctx, 134, RULE_singletonTagName); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1722); | |
| _la = _input.LA(1); | |
| 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)) | (1L << (EMBED_HTML_TAG_NAME - 74)) | (1L << (KEYGEN_HTML_TAG_NAME - 74)) | (1L << (SOURCE_HTML_TAG_NAME - 74)) | (1L << (TRACK_HTML_TAG_NAME - 74)) | (1L << (WBR_HTML_TAG_NAME - 74)))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class DescriptionContext extends ParserRuleContext { | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<HtmlElementContext> htmlElement() { | |
| return getRuleContexts(HtmlElementContext.class); | |
| } | |
| public HtmlElementContext htmlElement(int i) { | |
| return getRuleContext(HtmlElementContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public DescriptionContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_description; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitDescription(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final DescriptionContext description() throws RecognitionException { | |
| DescriptionContext _localctx = new DescriptionContext(_ctx, getState()); | |
| enterRule(_localctx, 136, RULE_description); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1731); | |
| _errHandler.sync(this); | |
| _alt = 1; | |
| do { | |
| switch (_alt) { | |
| case 1: | |
| { | |
| setState(1731); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) { | |
| case 1: | |
| { | |
| { | |
| setState(1724); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(1725); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(1726); | |
| htmlComment(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(1727); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(1728); | |
| text(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(1729); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(1730); | |
| htmlElement(); | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| setState(1733); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,119,_ctx); | |
| } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class ReferenceContext extends ParserRuleContext { | |
| public TerminalNode PACKAGE_CLASS() { return getToken(JavadocParser.PACKAGE_CLASS, 0); } | |
| public TerminalNode HASH() { return getToken(JavadocParser.HASH, 0); } | |
| public TerminalNode MEMBER() { return getToken(JavadocParser.MEMBER, 0); } | |
| public ParametersContext parameters() { | |
| return getRuleContext(ParametersContext.class,0); | |
| } | |
| public ReferenceContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_reference; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitReference(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final ReferenceContext reference() throws RecognitionException { | |
| ReferenceContext _localctx = new ReferenceContext(_ctx, getState()); | |
| enterRule(_localctx, 138, RULE_reference); | |
| int _la; | |
| try { | |
| setState(1748); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case PACKAGE_CLASS: | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1735); | |
| match(PACKAGE_CLASS); | |
| setState(1741); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| if (_la==HASH) { | |
| { | |
| setState(1736); | |
| match(HASH); | |
| setState(1737); | |
| match(MEMBER); | |
| setState(1739); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| if (_la==LEFT_BRACE) { | |
| { | |
| setState(1738); | |
| parameters(); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| break; | |
| case HASH: | |
| enterOuterAlt(_localctx, 2); | |
| { | |
| setState(1743); | |
| match(HASH); | |
| setState(1744); | |
| match(MEMBER); | |
| setState(1746); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| if (_la==LEFT_BRACE) { | |
| { | |
| setState(1745); | |
| parameters(); | |
| } | |
| } | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class ParametersContext extends ParserRuleContext { | |
| public TerminalNode LEFT_BRACE() { return getToken(JavadocParser.LEFT_BRACE, 0); } | |
| public TerminalNode RIGHT_BRACE() { return getToken(JavadocParser.RIGHT_BRACE, 0); } | |
| public List<TerminalNode> ARGUMENT() { return getTokens(JavadocParser.ARGUMENT); } | |
| public TerminalNode ARGUMENT(int i) { | |
| return getToken(JavadocParser.ARGUMENT, i); | |
| } | |
| public List<TerminalNode> COMMA() { return getTokens(JavadocParser.COMMA); } | |
| public TerminalNode COMMA(int i) { | |
| return getToken(JavadocParser.COMMA, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public ParametersContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_parameters; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitParameters(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final ParametersContext parameters() throws RecognitionException { | |
| ParametersContext _localctx = new ParametersContext(_ctx, getState()); | |
| enterRule(_localctx, 140, RULE_parameters); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1750); | |
| match(LEFT_BRACE); | |
| setState(1754); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) { | |
| { | |
| { | |
| setState(1751); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << ARGUMENT) | (1L << COMMA))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(1756); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(1757); | |
| match(RIGHT_BRACE); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class JavadocTagContext extends ParserRuleContext { | |
| public TerminalNode AUTHOR_LITERAL() { return getToken(JavadocParser.AUTHOR_LITERAL, 0); } | |
| public DescriptionContext description() { | |
| return getRuleContext(DescriptionContext.class,0); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public TerminalNode DEPRECATED_LITERAL() { return getToken(JavadocParser.DEPRECATED_LITERAL, 0); } | |
| public TerminalNode EXCEPTION_LITERAL() { return getToken(JavadocParser.EXCEPTION_LITERAL, 0); } | |
| public TerminalNode CLASS_NAME() { return getToken(JavadocParser.CLASS_NAME, 0); } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public TerminalNode PARAM_LITERAL() { return getToken(JavadocParser.PARAM_LITERAL, 0); } | |
| public TerminalNode PARAMETER_NAME() { return getToken(JavadocParser.PARAMETER_NAME, 0); } | |
| public TerminalNode RETURN_LITERAL() { return getToken(JavadocParser.RETURN_LITERAL, 0); } | |
| public TerminalNode SEE_LITERAL() { return getToken(JavadocParser.SEE_LITERAL, 0); } | |
| public ReferenceContext reference() { | |
| return getRuleContext(ReferenceContext.class,0); | |
| } | |
| public TerminalNode STRING() { return getToken(JavadocParser.STRING, 0); } | |
| public HtmlElementContext htmlElement() { | |
| return getRuleContext(HtmlElementContext.class,0); | |
| } | |
| public TerminalNode SERIAL_LITERAL() { return getToken(JavadocParser.SERIAL_LITERAL, 0); } | |
| public TerminalNode LITERAL_INCLUDE() { return getToken(JavadocParser.LITERAL_INCLUDE, 0); } | |
| public TerminalNode LITERAL_EXCLUDE() { return getToken(JavadocParser.LITERAL_EXCLUDE, 0); } | |
| public TerminalNode SERIAL_DATA_LITERAL() { return getToken(JavadocParser.SERIAL_DATA_LITERAL, 0); } | |
| public TerminalNode SERIAL_FIELD_LITERAL() { return getToken(JavadocParser.SERIAL_FIELD_LITERAL, 0); } | |
| public TerminalNode FIELD_NAME() { return getToken(JavadocParser.FIELD_NAME, 0); } | |
| public TerminalNode FIELD_TYPE() { return getToken(JavadocParser.FIELD_TYPE, 0); } | |
| public TerminalNode SINCE_LITERAL() { return getToken(JavadocParser.SINCE_LITERAL, 0); } | |
| public TerminalNode THROWS_LITERAL() { return getToken(JavadocParser.THROWS_LITERAL, 0); } | |
| public TerminalNode VERSION_LITERAL() { return getToken(JavadocParser.VERSION_LITERAL, 0); } | |
| public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } | |
| public JavadocTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_javadocTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final JavadocTagContext javadocTag() throws RecognitionException { | |
| JavadocTagContext _localctx = new JavadocTagContext(_ctx, getState()); | |
| enterRule(_localctx, 142, RULE_javadocTag); | |
| int _la; | |
| try { | |
| int _alt; | |
| setState(1954); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case AUTHOR_LITERAL: | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1759); | |
| match(AUTHOR_LITERAL); | |
| setState(1761); | |
| _errHandler.sync(this); | |
| _alt = 1; | |
| do { | |
| switch (_alt) { | |
| case 1: | |
| { | |
| { | |
| setState(1760); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| setState(1763); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,125,_ctx); | |
| } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); | |
| setState(1765); | |
| description(); | |
| } | |
| break; | |
| case DEPRECATED_LITERAL: | |
| enterOuterAlt(_localctx, 2); | |
| { | |
| setState(1766); | |
| match(DEPRECATED_LITERAL); | |
| setState(1770); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,126,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(1767); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(1772); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,126,_ctx); | |
| } | |
| setState(1775); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1773); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| setState(1774); | |
| description(); | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| case EXCEPTION_LITERAL: | |
| enterOuterAlt(_localctx, 3); | |
| { | |
| setState(1777); | |
| match(EXCEPTION_LITERAL); | |
| setState(1782); | |
| _errHandler.sync(this); | |
| _alt = 1; | |
| do { | |
| switch (_alt) { | |
| case 1: | |
| { | |
| setState(1782); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1778); | |
| match(WS); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(1779); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(1780); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(1781); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| setState(1784); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,129,_ctx); | |
| } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); | |
| setState(1786); | |
| match(CLASS_NAME); | |
| setState(1790); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,130,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(1787); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(1792); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,130,_ctx); | |
| } | |
| setState(1795); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1793); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| setState(1794); | |
| description(); | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| case PARAM_LITERAL: | |
| enterOuterAlt(_localctx, 4); | |
| { | |
| setState(1797); | |
| match(PARAM_LITERAL); | |
| setState(1802); | |
| _errHandler.sync(this); | |
| _alt = 1; | |
| do { | |
| switch (_alt) { | |
| case 1: | |
| { | |
| setState(1802); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,132,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1798); | |
| match(WS); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(1799); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(1800); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(1801); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| setState(1804); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,133,_ctx); | |
| } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); | |
| setState(1806); | |
| match(PARAMETER_NAME); | |
| setState(1810); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,134,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(1807); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(1812); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,134,_ctx); | |
| } | |
| setState(1815); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1813); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| setState(1814); | |
| description(); | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| case RETURN_LITERAL: | |
| enterOuterAlt(_localctx, 5); | |
| { | |
| setState(1817); | |
| match(RETURN_LITERAL); | |
| setState(1819); | |
| _errHandler.sync(this); | |
| _alt = 1; | |
| do { | |
| switch (_alt) { | |
| case 1: | |
| { | |
| { | |
| setState(1818); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| setState(1821); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,136,_ctx); | |
| } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); | |
| setState(1823); | |
| description(); | |
| } | |
| break; | |
| case SEE_LITERAL: | |
| enterOuterAlt(_localctx, 6); | |
| { | |
| setState(1824); | |
| match(SEE_LITERAL); | |
| setState(1829); | |
| _errHandler.sync(this); | |
| _alt = 1; | |
| do { | |
| switch (_alt) { | |
| case 1: | |
| { | |
| setState(1829); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1825); | |
| match(WS); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(1826); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(1827); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(1828); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| setState(1831); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,138,_ctx); | |
| } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); | |
| setState(1836); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case PACKAGE_CLASS: | |
| case HASH: | |
| { | |
| setState(1833); | |
| reference(); | |
| } | |
| break; | |
| case STRING: | |
| { | |
| setState(1834); | |
| match(STRING); | |
| } | |
| break; | |
| case START: | |
| { | |
| setState(1835); | |
| htmlElement(); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| setState(1841); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,140,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(1838); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(1843); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,140,_ctx); | |
| } | |
| setState(1846); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1844); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| setState(1845); | |
| description(); | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| case SERIAL_LITERAL: | |
| enterOuterAlt(_localctx, 7); | |
| { | |
| setState(1848); | |
| match(SERIAL_LITERAL); | |
| setState(1852); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,142,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(1849); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(1854); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,142,_ctx); | |
| } | |
| setState(1859); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1855); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| setState(1856); | |
| description(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(1857); | |
| match(LITERAL_INCLUDE); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(1858); | |
| match(LITERAL_EXCLUDE); | |
| } | |
| break; | |
| } | |
| setState(1864); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,144,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(1861); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(1866); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,144,_ctx); | |
| } | |
| } | |
| break; | |
| case SERIAL_DATA_LITERAL: | |
| enterOuterAlt(_localctx, 8); | |
| { | |
| setState(1867); | |
| match(SERIAL_DATA_LITERAL); | |
| setState(1871); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,145,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(1868); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(1873); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,145,_ctx); | |
| } | |
| setState(1876); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1874); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| setState(1875); | |
| description(); | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| case SERIAL_FIELD_LITERAL: | |
| enterOuterAlt(_localctx, 9); | |
| { | |
| setState(1878); | |
| match(SERIAL_FIELD_LITERAL); | |
| setState(1882); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,147,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(1879); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(1884); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,147,_ctx); | |
| } | |
| setState(1887); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1885); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| setState(1886); | |
| match(FIELD_NAME); | |
| } | |
| break; | |
| } | |
| setState(1892); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,149,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(1889); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(1894); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,149,_ctx); | |
| } | |
| setState(1897); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1895); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| setState(1896); | |
| match(FIELD_TYPE); | |
| } | |
| break; | |
| } | |
| setState(1902); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,151,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(1899); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(1904); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,151,_ctx); | |
| } | |
| setState(1907); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1905); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| setState(1906); | |
| description(); | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| case SINCE_LITERAL: | |
| enterOuterAlt(_localctx, 10); | |
| { | |
| setState(1909); | |
| match(SINCE_LITERAL); | |
| setState(1911); | |
| _errHandler.sync(this); | |
| _alt = 1; | |
| do { | |
| switch (_alt) { | |
| case 1: | |
| { | |
| { | |
| setState(1910); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| setState(1913); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,153,_ctx); | |
| } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); | |
| setState(1915); | |
| description(); | |
| } | |
| break; | |
| case THROWS_LITERAL: | |
| enterOuterAlt(_localctx, 11); | |
| { | |
| setState(1916); | |
| match(THROWS_LITERAL); | |
| setState(1921); | |
| _errHandler.sync(this); | |
| _alt = 1; | |
| do { | |
| switch (_alt) { | |
| case 1: | |
| { | |
| setState(1921); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,154,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1917); | |
| match(WS); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(1918); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(1919); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(1920); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| setState(1923); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,155,_ctx); | |
| } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); | |
| setState(1925); | |
| match(CLASS_NAME); | |
| setState(1929); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,156,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(1926); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(1931); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,156,_ctx); | |
| } | |
| setState(1934); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1932); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| setState(1933); | |
| description(); | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| case VERSION_LITERAL: | |
| enterOuterAlt(_localctx, 12); | |
| { | |
| setState(1936); | |
| match(VERSION_LITERAL); | |
| setState(1938); | |
| _errHandler.sync(this); | |
| _alt = 1; | |
| do { | |
| switch (_alt) { | |
| case 1: | |
| { | |
| { | |
| setState(1937); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| setState(1940); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,158,_ctx); | |
| } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); | |
| setState(1942); | |
| description(); | |
| } | |
| break; | |
| case CUSTOM_NAME: | |
| enterOuterAlt(_localctx, 13); | |
| { | |
| setState(1943); | |
| match(CUSTOM_NAME); | |
| setState(1947); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,159,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(1944); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(1949); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,159,_ctx); | |
| } | |
| setState(1952); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1950); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| setState(1951); | |
| description(); | |
| } | |
| break; | |
| } | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class JavadocInlineTagContext extends ParserRuleContext { | |
| public TerminalNode JAVADOC_INLINE_TAG_START() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_START, 0); } | |
| public TerminalNode JAVADOC_INLINE_TAG_END() { return getToken(JavadocParser.JAVADOC_INLINE_TAG_END, 0); } | |
| public TerminalNode CODE_LITERAL() { return getToken(JavadocParser.CODE_LITERAL, 0); } | |
| public TerminalNode DOC_ROOT_LITERAL() { return getToken(JavadocParser.DOC_ROOT_LITERAL, 0); } | |
| public TerminalNode INHERIT_DOC_LITERAL() { return getToken(JavadocParser.INHERIT_DOC_LITERAL, 0); } | |
| public TerminalNode LINK_LITERAL() { return getToken(JavadocParser.LINK_LITERAL, 0); } | |
| public ReferenceContext reference() { | |
| return getRuleContext(ReferenceContext.class,0); | |
| } | |
| public TerminalNode LINKPLAIN_LITERAL() { return getToken(JavadocParser.LINKPLAIN_LITERAL, 0); } | |
| public TerminalNode LITERAL_LITERAL() { return getToken(JavadocParser.LITERAL_LITERAL, 0); } | |
| public TerminalNode VALUE_LITERAL() { return getToken(JavadocParser.VALUE_LITERAL, 0); } | |
| public TerminalNode CUSTOM_NAME() { return getToken(JavadocParser.CUSTOM_NAME, 0); } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public DescriptionContext description() { | |
| return getRuleContext(DescriptionContext.class,0); | |
| } | |
| public JavadocInlineTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_javadocInlineTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitJavadocInlineTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final JavadocInlineTagContext javadocInlineTag() throws RecognitionException { | |
| JavadocInlineTagContext _localctx = new JavadocInlineTagContext(_ctx, getState()); | |
| enterRule(_localctx, 144, RULE_javadocInlineTag); | |
| int _la; | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(1956); | |
| match(JAVADOC_INLINE_TAG_START); | |
| setState(2047); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case CODE_LITERAL: | |
| { | |
| setState(1957); | |
| match(CODE_LITERAL); | |
| setState(1964); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { | |
| { | |
| setState(1962); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) { | |
| case 1: | |
| { | |
| setState(1958); | |
| match(WS); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(1959); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(1960); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(1961); | |
| text(); | |
| } | |
| break; | |
| } | |
| } | |
| setState(1966); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| } | |
| break; | |
| case DOC_ROOT_LITERAL: | |
| { | |
| setState(1967); | |
| match(DOC_ROOT_LITERAL); | |
| setState(1971); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(1968); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(1973); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| } | |
| break; | |
| case INHERIT_DOC_LITERAL: | |
| { | |
| setState(1974); | |
| match(INHERIT_DOC_LITERAL); | |
| setState(1978); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(1975); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(1980); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| } | |
| break; | |
| case LINK_LITERAL: | |
| { | |
| setState(1981); | |
| match(LINK_LITERAL); | |
| setState(1983); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| do { | |
| { | |
| { | |
| setState(1982); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(1985); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) ); | |
| setState(1987); | |
| reference(); | |
| setState(1991); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,167,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(1988); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(1993); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,167,_ctx); | |
| } | |
| setState(1996); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| if (_la==WS || _la==NEWLINE) { | |
| { | |
| setState(1994); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| setState(1995); | |
| description(); | |
| } | |
| } | |
| } | |
| break; | |
| case LINKPLAIN_LITERAL: | |
| { | |
| setState(1998); | |
| match(LINKPLAIN_LITERAL); | |
| setState(2000); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| do { | |
| { | |
| { | |
| setState(1999); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(2002); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) ); | |
| setState(2004); | |
| reference(); | |
| setState(2008); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,170,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(2005); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(2010); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,170,_ctx); | |
| } | |
| setState(2013); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| if (_la==WS || _la==NEWLINE) { | |
| { | |
| setState(2011); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| setState(2012); | |
| description(); | |
| } | |
| } | |
| } | |
| break; | |
| case LITERAL_LITERAL: | |
| { | |
| setState(2015); | |
| match(LITERAL_LITERAL); | |
| setState(2022); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { | |
| { | |
| setState(2020); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) { | |
| case 1: | |
| { | |
| setState(2016); | |
| match(WS); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(2017); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(2018); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(2019); | |
| text(); | |
| } | |
| break; | |
| } | |
| } | |
| setState(2024); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| } | |
| break; | |
| case VALUE_LITERAL: | |
| { | |
| setState(2025); | |
| match(VALUE_LITERAL); | |
| setState(2029); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,174,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(2026); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(2031); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,174,_ctx); | |
| } | |
| setState(2034); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| if (_la==WS || _la==NEWLINE) { | |
| { | |
| setState(2032); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| setState(2033); | |
| reference(); | |
| } | |
| } | |
| } | |
| break; | |
| case CUSTOM_NAME: | |
| { | |
| setState(2036); | |
| match(CUSTOM_NAME); | |
| setState(2040); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,176,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| { | |
| setState(2037); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| } | |
| setState(2042); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,176,_ctx); | |
| } | |
| setState(2045); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| if (_la==WS || _la==NEWLINE) { | |
| { | |
| setState(2043); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==NEWLINE) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| setState(2044); | |
| description(); | |
| } | |
| } | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| setState(2049); | |
| match(JAVADOC_INLINE_TAG_END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class HtmlCommentContext extends ParserRuleContext { | |
| public TerminalNode HTML_COMMENT_START() { return getToken(JavadocParser.HTML_COMMENT_START, 0); } | |
| public TerminalNode HTML_COMMENT_END() { return getToken(JavadocParser.HTML_COMMENT_END, 0); } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public HtmlCommentContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_htmlComment; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitHtmlComment(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final HtmlCommentContext htmlComment() throws RecognitionException { | |
| HtmlCommentContext _localctx = new HtmlCommentContext(_ctx, getState()); | |
| enterRule(_localctx, 146, RULE_htmlComment); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2051); | |
| match(HTML_COMMENT_START); | |
| setState(2057); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE) | (1L << CHAR))) != 0)) { | |
| { | |
| setState(2055); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case WS: | |
| case CHAR: | |
| { | |
| setState(2052); | |
| text(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(2053); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(2054); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(2059); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(2060); | |
| match(HTML_COMMENT_END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TextContext extends ParserRuleContext { | |
| public List<TerminalNode> CHAR() { return getTokens(JavadocParser.CHAR); } | |
| public TerminalNode CHAR(int i) { | |
| return getToken(JavadocParser.CHAR, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public TextContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_text; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitText(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TextContext text() throws RecognitionException { | |
| TextContext _localctx = new TextContext(_ctx, getState()); | |
| enterRule(_localctx, 148, RULE_text); | |
| int _la; | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2064); | |
| _errHandler.sync(this); | |
| _alt = 1; | |
| do { | |
| switch (_alt) { | |
| case 1: | |
| { | |
| { | |
| setState(2062); | |
| _la = _input.LA(1); | |
| if ( !(_la==WS || _la==CHAR) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| _la = _input.LA(1); | |
| if ((_la != WS) && (_la != CHAR)) return _localctx; | |
| else if (_alt == 1) continue; | |
| } | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| setState(2066); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,181,_ctx); | |
| } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class EmbedTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode EMBED_HTML_TAG_NAME() { return getToken(JavadocParser.EMBED_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public EmbedTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_embedTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitEmbedTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final EmbedTagContext embedTag() throws RecognitionException { | |
| EmbedTagContext _localctx = new EmbedTagContext(_ctx, getState()); | |
| enterRule(_localctx, 150, RULE_embedTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2068); | |
| match(START); | |
| setState(2069); | |
| match(EMBED_HTML_TAG_NAME); | |
| setState(2076); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(2074); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(2070); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(2071); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(2072); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(2073); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(2078); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(2079); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class KeygenTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode KEYGEN_HTML_TAG_NAME() { return getToken(JavadocParser.KEYGEN_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public KeygenTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_keygenTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitKeygenTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final KeygenTagContext keygenTag() throws RecognitionException { | |
| KeygenTagContext _localctx = new KeygenTagContext(_ctx, getState()); | |
| enterRule(_localctx, 152, RULE_keygenTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2081); | |
| match(START); | |
| setState(2082); | |
| match(KEYGEN_HTML_TAG_NAME); | |
| setState(2089); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(2087); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(2083); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(2084); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(2085); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(2086); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(2091); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(2092); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class SourceTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SOURCE_HTML_TAG_NAME() { return getToken(JavadocParser.SOURCE_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public SourceTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_sourceTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitSourceTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final SourceTagContext sourceTag() throws RecognitionException { | |
| SourceTagContext _localctx = new SourceTagContext(_ctx, getState()); | |
| enterRule(_localctx, 154, RULE_sourceTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2094); | |
| match(START); | |
| setState(2095); | |
| match(SOURCE_HTML_TAG_NAME); | |
| setState(2102); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(2100); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(2096); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(2097); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(2098); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(2099); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(2104); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(2105); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class TrackTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode TRACK_HTML_TAG_NAME() { return getToken(JavadocParser.TRACK_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public TrackTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_trackTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitTrackTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final TrackTagContext trackTag() throws RecognitionException { | |
| TrackTagContext _localctx = new TrackTagContext(_ctx, getState()); | |
| enterRule(_localctx, 156, RULE_trackTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2107); | |
| match(START); | |
| setState(2108); | |
| match(TRACK_HTML_TAG_NAME); | |
| setState(2115); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(2113); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(2109); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(2110); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(2111); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(2112); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(2117); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(2118); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class WbrTagContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode WBR_HTML_TAG_NAME() { return getToken(JavadocParser.WBR_HTML_TAG_NAME, 0); } | |
| public TerminalNode SLASH_END() { return getToken(JavadocParser.SLASH_END, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public WbrTagContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_wbrTag; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitWbrTag(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final WbrTagContext wbrTag() throws RecognitionException { | |
| WbrTagContext _localctx = new WbrTagContext(_ctx, getState()); | |
| enterRule(_localctx, 158, RULE_wbrTag); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2120); | |
| match(START); | |
| setState(2121); | |
| match(WBR_HTML_TAG_NAME); | |
| setState(2128); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(2126); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(2122); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(2123); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(2124); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(2125); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(2130); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(2131); | |
| _la = _input.LA(1); | |
| if ( !(_la==END || _la==SLASH_END) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class OptgroupTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode OPTGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.OPTGROUP_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public OptgroupTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public OptgroupTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_optgroupTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptgroupTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final OptgroupTagStartContext optgroupTagStart(boolean isNonTight) throws RecognitionException { | |
| OptgroupTagStartContext _localctx = new OptgroupTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 160, RULE_optgroupTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2133); | |
| match(START); | |
| setState(2134); | |
| match(OPTGROUP_HTML_TAG_NAME); | |
| setState(2141); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(2139); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(2135); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(2136); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(2137); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(2138); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(2143); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(2144); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class OptgroupTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode OPTGROUP_HTML_TAG_NAME() { return getToken(JavadocParser.OPTGROUP_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public OptgroupTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_optgroupTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptgroupTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final OptgroupTagEndContext optgroupTagEnd() throws RecognitionException { | |
| OptgroupTagEndContext _localctx = new OptgroupTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 162, RULE_optgroupTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2146); | |
| match(START); | |
| setState(2147); | |
| match(SLASH); | |
| setState(2148); | |
| match(OPTGROUP_HTML_TAG_NAME); | |
| setState(2152); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(2149); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(2154); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(2155); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class OptgroupContext extends ParserRuleContext { | |
| public OptgroupTagStartContext optgroupTagStart() { | |
| return getRuleContext(OptgroupTagStartContext.class,0); | |
| } | |
| public OptgroupTagEndContext optgroupTagEnd() { | |
| return getRuleContext(OptgroupTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public OptgroupContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_optgroup; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitOptgroup(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final OptgroupContext optgroup() throws RecognitionException { | |
| OptgroupContext _localctx = new OptgroupContext(_ctx, getState()); | |
| enterRule(_localctx, 164, RULE_optgroup); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2157); | |
| optgroupTagStart(false); | |
| setState(2196); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,196,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(2194); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) { | |
| case 1: | |
| { | |
| setState(2158); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(2159); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(2160); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(2161); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(2162); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(2163); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(2164); | |
| th(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(2165); | |
| body(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(2166); | |
| colgroup(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(2167); | |
| dd(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(2168); | |
| dt(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(2169); | |
| head(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(2170); | |
| html(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(2171); | |
| option(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(2172); | |
| tbody(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(2173); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(2174); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(2175); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(2176); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(2177); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(2178); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(2179); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(2180); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(2181); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(2182); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(2183); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(2184); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(2185); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(2186); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(2187); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| { | |
| setState(2188); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(2189); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(2190); | |
| htmlComment(); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(2191); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(2192); | |
| text(); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(2193); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(2198); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,196,_ctx); | |
| } | |
| setState(2199); | |
| optgroupTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class RbTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode RB_HTML_TAG_NAME() { return getToken(JavadocParser.RB_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public RbTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public RbTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_rbTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitRbTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final RbTagStartContext rbTagStart(boolean isNonTight) throws RecognitionException { | |
| RbTagStartContext _localctx = new RbTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 166, RULE_rbTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2201); | |
| match(START); | |
| setState(2202); | |
| match(RB_HTML_TAG_NAME); | |
| setState(2209); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(2207); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(2203); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(2204); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(2205); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(2206); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(2211); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(2212); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class RbTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode RB_HTML_TAG_NAME() { return getToken(JavadocParser.RB_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public RbTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_rbTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitRbTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final RbTagEndContext rbTagEnd() throws RecognitionException { | |
| RbTagEndContext _localctx = new RbTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 168, RULE_rbTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2214); | |
| match(START); | |
| setState(2215); | |
| match(SLASH); | |
| setState(2216); | |
| match(RB_HTML_TAG_NAME); | |
| setState(2220); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(2217); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(2222); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(2223); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class RbContext extends ParserRuleContext { | |
| public RbTagStartContext rbTagStart() { | |
| return getRuleContext(RbTagStartContext.class,0); | |
| } | |
| public RbTagEndContext rbTagEnd() { | |
| return getRuleContext(RbTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public RbContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_rb; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitRb(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final RbContext rb() throws RecognitionException { | |
| RbContext _localctx = new RbContext(_ctx, getState()); | |
| enterRule(_localctx, 170, RULE_rb); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2225); | |
| rbTagStart(false); | |
| setState(2264); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,201,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(2262); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) { | |
| case 1: | |
| { | |
| setState(2226); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(2227); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(2228); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(2229); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(2230); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(2231); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(2232); | |
| th(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(2233); | |
| body(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(2234); | |
| colgroup(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(2235); | |
| dd(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(2236); | |
| dt(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(2237); | |
| head(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(2238); | |
| html(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(2239); | |
| option(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(2240); | |
| tbody(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(2241); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(2242); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(2243); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(2244); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(2245); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(2246); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(2247); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(2248); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(2249); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(2250); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(2251); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(2252); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(2253); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(2254); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(2255); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| { | |
| setState(2256); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(2257); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(2258); | |
| htmlComment(); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(2259); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(2260); | |
| text(); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(2261); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(2266); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,201,_ctx); | |
| } | |
| setState(2267); | |
| rbTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class RtTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode RT_HTML_TAG_NAME() { return getToken(JavadocParser.RT_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public RtTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public RtTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_rtTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitRtTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final RtTagStartContext rtTagStart(boolean isNonTight) throws RecognitionException { | |
| RtTagStartContext _localctx = new RtTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 172, RULE_rtTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2269); | |
| match(START); | |
| setState(2270); | |
| match(RT_HTML_TAG_NAME); | |
| setState(2277); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(2275); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(2271); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(2272); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(2273); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(2274); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(2279); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(2280); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class RtTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode RT_HTML_TAG_NAME() { return getToken(JavadocParser.RT_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public RtTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_rtTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitRtTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final RtTagEndContext rtTagEnd() throws RecognitionException { | |
| RtTagEndContext _localctx = new RtTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 174, RULE_rtTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2282); | |
| match(START); | |
| setState(2283); | |
| match(SLASH); | |
| setState(2284); | |
| match(RT_HTML_TAG_NAME); | |
| setState(2288); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(2285); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(2290); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(2291); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class RtContext extends ParserRuleContext { | |
| public RtTagStartContext rtTagStart() { | |
| return getRuleContext(RtTagStartContext.class,0); | |
| } | |
| public RtTagEndContext rtTagEnd() { | |
| return getRuleContext(RtTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public RtContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_rt; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitRt(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final RtContext rt() throws RecognitionException { | |
| RtContext _localctx = new RtContext(_ctx, getState()); | |
| enterRule(_localctx, 176, RULE_rt); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2293); | |
| rtTagStart(false); | |
| setState(2332); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,206,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(2330); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,205,_ctx) ) { | |
| case 1: | |
| { | |
| setState(2294); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(2295); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(2296); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(2297); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(2298); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(2299); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(2300); | |
| th(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(2301); | |
| body(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(2302); | |
| colgroup(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(2303); | |
| dd(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(2304); | |
| dt(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(2305); | |
| head(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(2306); | |
| html(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(2307); | |
| option(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(2308); | |
| tbody(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(2309); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(2310); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(2311); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(2312); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(2313); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(2314); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(2315); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(2316); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(2317); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(2318); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(2319); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(2320); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(2321); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(2322); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(2323); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| { | |
| setState(2324); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(2325); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(2326); | |
| htmlComment(); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(2327); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(2328); | |
| text(); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(2329); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(2334); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,206,_ctx); | |
| } | |
| setState(2335); | |
| rtTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class RtcTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode RTC_HTML_TAG_NAME() { return getToken(JavadocParser.RTC_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public RtcTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public RtcTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_rtcTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitRtcTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final RtcTagStartContext rtcTagStart(boolean isNonTight) throws RecognitionException { | |
| RtcTagStartContext _localctx = new RtcTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 178, RULE_rtcTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2337); | |
| match(START); | |
| setState(2338); | |
| match(RTC_HTML_TAG_NAME); | |
| setState(2345); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(2343); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(2339); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(2340); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(2341); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(2342); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(2347); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(2348); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class RtcTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode RTC_HTML_TAG_NAME() { return getToken(JavadocParser.RTC_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public RtcTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_rtcTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitRtcTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final RtcTagEndContext rtcTagEnd() throws RecognitionException { | |
| RtcTagEndContext _localctx = new RtcTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 180, RULE_rtcTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2350); | |
| match(START); | |
| setState(2351); | |
| match(SLASH); | |
| setState(2352); | |
| match(RTC_HTML_TAG_NAME); | |
| setState(2356); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(2353); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(2358); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(2359); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class RtcContext extends ParserRuleContext { | |
| public RtcTagStartContext rtcTagStart() { | |
| return getRuleContext(RtcTagStartContext.class,0); | |
| } | |
| public RtcTagEndContext rtcTagEnd() { | |
| return getRuleContext(RtcTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public RtcContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_rtc; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitRtc(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final RtcContext rtc() throws RecognitionException { | |
| RtcContext _localctx = new RtcContext(_ctx, getState()); | |
| enterRule(_localctx, 182, RULE_rtc); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2361); | |
| rtcTagStart(false); | |
| setState(2400); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,211,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(2398); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,210,_ctx) ) { | |
| case 1: | |
| { | |
| setState(2362); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(2363); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(2364); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(2365); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(2366); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(2367); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(2368); | |
| th(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(2369); | |
| body(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(2370); | |
| colgroup(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(2371); | |
| dd(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(2372); | |
| dt(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(2373); | |
| head(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(2374); | |
| html(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(2375); | |
| option(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(2376); | |
| tbody(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(2377); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(2378); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(2379); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(2380); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(2381); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(2382); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(2383); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(2384); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(2385); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(2386); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(2387); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(2388); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(2389); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(2390); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(2391); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| { | |
| setState(2392); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(2393); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(2394); | |
| htmlComment(); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(2395); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(2396); | |
| text(); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(2397); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(2402); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,211,_ctx); | |
| } | |
| setState(2403); | |
| rtcTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class RpTagStartContext extends ParserRuleContext { | |
| public boolean isNonTight; | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode RP_HTML_TAG_NAME() { return getToken(JavadocParser.RP_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<AttributeContext> attribute() { | |
| return getRuleContexts(AttributeContext.class); | |
| } | |
| public AttributeContext attribute(int i) { | |
| return getRuleContext(AttributeContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public RpTagStartContext(ParserRuleContext parent, int invokingState) { super(parent, invokingState); } | |
| public RpTagStartContext(ParserRuleContext parent, int invokingState, boolean isNonTight) { | |
| super(parent, invokingState); | |
| this.isNonTight = isNonTight; | |
| } | |
| @Override public int getRuleIndex() { return RULE_rpTagStart; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitRpTagStart(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final RpTagStartContext rpTagStart(boolean isNonTight) throws RecognitionException { | |
| RpTagStartContext _localctx = new RpTagStartContext(_ctx, getState(), isNonTight); | |
| enterRule(_localctx, 184, RULE_rpTagStart); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2405); | |
| match(START); | |
| setState(2406); | |
| match(RP_HTML_TAG_NAME); | |
| setState(2413); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0) || _la==HTML_TAG_NAME) { | |
| { | |
| setState(2411); | |
| _errHandler.sync(this); | |
| switch (_input.LA(1)) { | |
| case HTML_TAG_NAME: | |
| { | |
| setState(2407); | |
| attribute(); | |
| } | |
| break; | |
| case NEWLINE: | |
| { | |
| setState(2408); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case LEADING_ASTERISK: | |
| { | |
| setState(2409); | |
| match(LEADING_ASTERISK); | |
| } | |
| break; | |
| case WS: | |
| { | |
| setState(2410); | |
| match(WS); | |
| } | |
| break; | |
| default: | |
| throw new NoViableAltException(this); | |
| } | |
| } | |
| setState(2415); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(2416); | |
| match(END); | |
| } | |
| _ctx.stop = _input.LT(-1); | |
| if (isNonTight && nonTightTagStartContext == null) { | |
| nonTightTagStartContext = _localctx; | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class RpTagEndContext extends ParserRuleContext { | |
| public TerminalNode START() { return getToken(JavadocParser.START, 0); } | |
| public TerminalNode SLASH() { return getToken(JavadocParser.SLASH, 0); } | |
| public TerminalNode RP_HTML_TAG_NAME() { return getToken(JavadocParser.RP_HTML_TAG_NAME, 0); } | |
| public TerminalNode END() { return getToken(JavadocParser.END, 0); } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public List<TerminalNode> WS() { return getTokens(JavadocParser.WS); } | |
| public TerminalNode WS(int i) { | |
| return getToken(JavadocParser.WS, i); | |
| } | |
| public RpTagEndContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_rpTagEnd; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitRpTagEnd(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final RpTagEndContext rpTagEnd() throws RecognitionException { | |
| RpTagEndContext _localctx = new RpTagEndContext(_ctx, getState()); | |
| enterRule(_localctx, 186, RULE_rpTagEnd); | |
| int _la; | |
| try { | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2418); | |
| match(START); | |
| setState(2419); | |
| match(SLASH); | |
| setState(2420); | |
| match(RP_HTML_TAG_NAME); | |
| setState(2424); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) { | |
| { | |
| { | |
| setState(2421); | |
| _la = _input.LA(1); | |
| if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LEADING_ASTERISK) | (1L << WS) | (1L << NEWLINE))) != 0)) ) { | |
| _errHandler.recoverInline(this); | |
| } | |
| else { | |
| if ( _input.LA(1)==Token.EOF ) matchedEOF = true; | |
| _errHandler.reportMatch(this); | |
| consume(); | |
| } | |
| } | |
| } | |
| setState(2426); | |
| _errHandler.sync(this); | |
| _la = _input.LA(1); | |
| } | |
| setState(2427); | |
| match(END); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public static class RpContext extends ParserRuleContext { | |
| public RpTagStartContext rpTagStart() { | |
| return getRuleContext(RpTagStartContext.class,0); | |
| } | |
| public RpTagEndContext rpTagEnd() { | |
| return getRuleContext(RpTagEndContext.class,0); | |
| } | |
| public List<HtmlTagContext> htmlTag() { | |
| return getRuleContexts(HtmlTagContext.class); | |
| } | |
| public HtmlTagContext htmlTag(int i) { | |
| return getRuleContext(HtmlTagContext.class,i); | |
| } | |
| public List<SingletonElementContext> singletonElement() { | |
| return getRuleContexts(SingletonElementContext.class); | |
| } | |
| public SingletonElementContext singletonElement(int i) { | |
| return getRuleContext(SingletonElementContext.class,i); | |
| } | |
| public List<ParagraphContext> paragraph() { | |
| return getRuleContexts(ParagraphContext.class); | |
| } | |
| public ParagraphContext paragraph(int i) { | |
| return getRuleContext(ParagraphContext.class,i); | |
| } | |
| public List<LiContext> li() { | |
| return getRuleContexts(LiContext.class); | |
| } | |
| public LiContext li(int i) { | |
| return getRuleContext(LiContext.class,i); | |
| } | |
| public List<TrContext> tr() { | |
| return getRuleContexts(TrContext.class); | |
| } | |
| public TrContext tr(int i) { | |
| return getRuleContext(TrContext.class,i); | |
| } | |
| public List<TdContext> td() { | |
| return getRuleContexts(TdContext.class); | |
| } | |
| public TdContext td(int i) { | |
| return getRuleContext(TdContext.class,i); | |
| } | |
| public List<ThContext> th() { | |
| return getRuleContexts(ThContext.class); | |
| } | |
| public ThContext th(int i) { | |
| return getRuleContext(ThContext.class,i); | |
| } | |
| public List<BodyContext> body() { | |
| return getRuleContexts(BodyContext.class); | |
| } | |
| public BodyContext body(int i) { | |
| return getRuleContext(BodyContext.class,i); | |
| } | |
| public List<ColgroupContext> colgroup() { | |
| return getRuleContexts(ColgroupContext.class); | |
| } | |
| public ColgroupContext colgroup(int i) { | |
| return getRuleContext(ColgroupContext.class,i); | |
| } | |
| public List<DdContext> dd() { | |
| return getRuleContexts(DdContext.class); | |
| } | |
| public DdContext dd(int i) { | |
| return getRuleContext(DdContext.class,i); | |
| } | |
| public List<DtContext> dt() { | |
| return getRuleContexts(DtContext.class); | |
| } | |
| public DtContext dt(int i) { | |
| return getRuleContext(DtContext.class,i); | |
| } | |
| public List<HeadContext> head() { | |
| return getRuleContexts(HeadContext.class); | |
| } | |
| public HeadContext head(int i) { | |
| return getRuleContext(HeadContext.class,i); | |
| } | |
| public List<HtmlContext> html() { | |
| return getRuleContexts(HtmlContext.class); | |
| } | |
| public HtmlContext html(int i) { | |
| return getRuleContext(HtmlContext.class,i); | |
| } | |
| public List<OptionContext> option() { | |
| return getRuleContexts(OptionContext.class); | |
| } | |
| public OptionContext option(int i) { | |
| return getRuleContext(OptionContext.class,i); | |
| } | |
| public List<TbodyContext> tbody() { | |
| return getRuleContexts(TbodyContext.class); | |
| } | |
| public TbodyContext tbody(int i) { | |
| return getRuleContext(TbodyContext.class,i); | |
| } | |
| public List<TfootContext> tfoot() { | |
| return getRuleContexts(TfootContext.class); | |
| } | |
| public TfootContext tfoot(int i) { | |
| return getRuleContext(TfootContext.class,i); | |
| } | |
| public List<PTagStartContext> pTagStart() { | |
| return getRuleContexts(PTagStartContext.class); | |
| } | |
| public PTagStartContext pTagStart(int i) { | |
| return getRuleContext(PTagStartContext.class,i); | |
| } | |
| public List<LiTagStartContext> liTagStart() { | |
| return getRuleContexts(LiTagStartContext.class); | |
| } | |
| public LiTagStartContext liTagStart(int i) { | |
| return getRuleContext(LiTagStartContext.class,i); | |
| } | |
| public List<TrTagStartContext> trTagStart() { | |
| return getRuleContexts(TrTagStartContext.class); | |
| } | |
| public TrTagStartContext trTagStart(int i) { | |
| return getRuleContext(TrTagStartContext.class,i); | |
| } | |
| public List<TdTagStartContext> tdTagStart() { | |
| return getRuleContexts(TdTagStartContext.class); | |
| } | |
| public TdTagStartContext tdTagStart(int i) { | |
| return getRuleContext(TdTagStartContext.class,i); | |
| } | |
| public List<ThTagStartContext> thTagStart() { | |
| return getRuleContexts(ThTagStartContext.class); | |
| } | |
| public ThTagStartContext thTagStart(int i) { | |
| return getRuleContext(ThTagStartContext.class,i); | |
| } | |
| public List<BodyTagStartContext> bodyTagStart() { | |
| return getRuleContexts(BodyTagStartContext.class); | |
| } | |
| public BodyTagStartContext bodyTagStart(int i) { | |
| return getRuleContext(BodyTagStartContext.class,i); | |
| } | |
| public List<ColgroupTagStartContext> colgroupTagStart() { | |
| return getRuleContexts(ColgroupTagStartContext.class); | |
| } | |
| public ColgroupTagStartContext colgroupTagStart(int i) { | |
| return getRuleContext(ColgroupTagStartContext.class,i); | |
| } | |
| public List<DdTagStartContext> ddTagStart() { | |
| return getRuleContexts(DdTagStartContext.class); | |
| } | |
| public DdTagStartContext ddTagStart(int i) { | |
| return getRuleContext(DdTagStartContext.class,i); | |
| } | |
| public List<DtTagStartContext> dtTagStart() { | |
| return getRuleContexts(DtTagStartContext.class); | |
| } | |
| public DtTagStartContext dtTagStart(int i) { | |
| return getRuleContext(DtTagStartContext.class,i); | |
| } | |
| public List<HeadTagStartContext> headTagStart() { | |
| return getRuleContexts(HeadTagStartContext.class); | |
| } | |
| public HeadTagStartContext headTagStart(int i) { | |
| return getRuleContext(HeadTagStartContext.class,i); | |
| } | |
| public List<HtmlTagStartContext> htmlTagStart() { | |
| return getRuleContexts(HtmlTagStartContext.class); | |
| } | |
| public HtmlTagStartContext htmlTagStart(int i) { | |
| return getRuleContext(HtmlTagStartContext.class,i); | |
| } | |
| public List<OptionTagStartContext> optionTagStart() { | |
| return getRuleContexts(OptionTagStartContext.class); | |
| } | |
| public OptionTagStartContext optionTagStart(int i) { | |
| return getRuleContext(OptionTagStartContext.class,i); | |
| } | |
| public List<TbodyTagStartContext> tbodyTagStart() { | |
| return getRuleContexts(TbodyTagStartContext.class); | |
| } | |
| public TbodyTagStartContext tbodyTagStart(int i) { | |
| return getRuleContext(TbodyTagStartContext.class,i); | |
| } | |
| public List<TfootTagStartContext> tfootTagStart() { | |
| return getRuleContexts(TfootTagStartContext.class); | |
| } | |
| public TfootTagStartContext tfootTagStart(int i) { | |
| return getRuleContext(TfootTagStartContext.class,i); | |
| } | |
| public List<HtmlCommentContext> htmlComment() { | |
| return getRuleContexts(HtmlCommentContext.class); | |
| } | |
| public HtmlCommentContext htmlComment(int i) { | |
| return getRuleContext(HtmlCommentContext.class,i); | |
| } | |
| public List<TerminalNode> NEWLINE() { return getTokens(JavadocParser.NEWLINE); } | |
| public TerminalNode NEWLINE(int i) { | |
| return getToken(JavadocParser.NEWLINE, i); | |
| } | |
| public List<TextContext> text() { | |
| return getRuleContexts(TextContext.class); | |
| } | |
| public TextContext text(int i) { | |
| return getRuleContext(TextContext.class,i); | |
| } | |
| public List<JavadocInlineTagContext> javadocInlineTag() { | |
| return getRuleContexts(JavadocInlineTagContext.class); | |
| } | |
| public JavadocInlineTagContext javadocInlineTag(int i) { | |
| return getRuleContext(JavadocInlineTagContext.class,i); | |
| } | |
| public List<TerminalNode> LEADING_ASTERISK() { return getTokens(JavadocParser.LEADING_ASTERISK); } | |
| public TerminalNode LEADING_ASTERISK(int i) { | |
| return getToken(JavadocParser.LEADING_ASTERISK, i); | |
| } | |
| public RpContext(ParserRuleContext parent, int invokingState) { | |
| super(parent, invokingState); | |
| } | |
| @Override public int getRuleIndex() { return RULE_rp; } | |
| @Override | |
| public <T> T accept(ParseTreeVisitor<? extends T> visitor) { | |
| if ( visitor instanceof JavadocParserVisitor ) return ((JavadocParserVisitor<? extends T>)visitor).visitRp(this); | |
| else return visitor.visitChildren(this); | |
| } | |
| } | |
| public final RpContext rp() throws RecognitionException { | |
| RpContext _localctx = new RpContext(_ctx, getState()); | |
| enterRule(_localctx, 188, RULE_rp); | |
| try { | |
| int _alt; | |
| enterOuterAlt(_localctx, 1); | |
| { | |
| setState(2429); | |
| rpTagStart(false); | |
| setState(2468); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,216,_ctx); | |
| while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { | |
| if ( _alt==1 ) { | |
| { | |
| setState(2466); | |
| _errHandler.sync(this); | |
| switch ( getInterpreter().adaptivePredict(_input,215,_ctx) ) { | |
| case 1: | |
| { | |
| setState(2430); | |
| htmlTag(); | |
| } | |
| break; | |
| case 2: | |
| { | |
| setState(2431); | |
| singletonElement(); | |
| } | |
| break; | |
| case 3: | |
| { | |
| setState(2432); | |
| paragraph(); | |
| } | |
| break; | |
| case 4: | |
| { | |
| setState(2433); | |
| li(); | |
| } | |
| break; | |
| case 5: | |
| { | |
| setState(2434); | |
| tr(); | |
| } | |
| break; | |
| case 6: | |
| { | |
| setState(2435); | |
| td(); | |
| } | |
| break; | |
| case 7: | |
| { | |
| setState(2436); | |
| th(); | |
| } | |
| break; | |
| case 8: | |
| { | |
| setState(2437); | |
| body(); | |
| } | |
| break; | |
| case 9: | |
| { | |
| setState(2438); | |
| colgroup(); | |
| } | |
| break; | |
| case 10: | |
| { | |
| setState(2439); | |
| dd(); | |
| } | |
| break; | |
| case 11: | |
| { | |
| setState(2440); | |
| dt(); | |
| } | |
| break; | |
| case 12: | |
| { | |
| setState(2441); | |
| head(); | |
| } | |
| break; | |
| case 13: | |
| { | |
| setState(2442); | |
| html(); | |
| } | |
| break; | |
| case 14: | |
| { | |
| setState(2443); | |
| option(); | |
| } | |
| break; | |
| case 15: | |
| { | |
| setState(2444); | |
| tbody(); | |
| } | |
| break; | |
| case 16: | |
| { | |
| setState(2445); | |
| tfoot(); | |
| } | |
| break; | |
| case 17: | |
| { | |
| setState(2446); | |
| pTagStart(true); | |
| } | |
| break; | |
| case 18: | |
| { | |
| setState(2447); | |
| liTagStart(true); | |
| } | |
| break; | |
| case 19: | |
| { | |
| setState(2448); | |
| trTagStart(true); | |
| } | |
| break; | |
| case 20: | |
| { | |
| setState(2449); | |
| tdTagStart(true); | |
| } | |
| break; | |
| case 21: | |
| { | |
| setState(2450); | |
| thTagStart(true); | |
| } | |
| break; | |
| case 22: | |
| { | |
| setState(2451); | |
| bodyTagStart(true); | |
| } | |
| break; | |
| case 23: | |
| { | |
| setState(2452); | |
| colgroupTagStart(true); | |
| } | |
| break; | |
| case 24: | |
| { | |
| setState(2453); | |
| ddTagStart(true); | |
| } | |
| break; | |
| case 25: | |
| { | |
| setState(2454); | |
| dtTagStart(true); | |
| } | |
| break; | |
| case 26: | |
| { | |
| setState(2455); | |
| headTagStart(true); | |
| } | |
| break; | |
| case 27: | |
| { | |
| setState(2456); | |
| htmlTagStart(true); | |
| } | |
| break; | |
| case 28: | |
| { | |
| setState(2457); | |
| optionTagStart(true); | |
| } | |
| break; | |
| case 29: | |
| { | |
| setState(2458); | |
| tbodyTagStart(true); | |
| } | |
| break; | |
| case 30: | |
| { | |
| setState(2459); | |
| tfootTagStart(true); | |
| } | |
| break; | |
| case 31: | |
| { | |
| { | |
| setState(2460); | |
| if (!(!isNextJavadocTag())) throw new FailedPredicateException(this, "!isNextJavadocTag()"); | |
| setState(2461); | |
| match(LEADING_ASTERISK); | |
| } | |
| } | |
| break; | |
| case 32: | |
| { | |
| setState(2462); | |
| htmlComment(); | |
| } | |
| break; | |
| case 33: | |
| { | |
| setState(2463); | |
| match(NEWLINE); | |
| } | |
| break; | |
| case 34: | |
| { | |
| setState(2464); | |
| text(); | |
| } | |
| break; | |
| case 35: | |
| { | |
| setState(2465); | |
| javadocInlineTag(); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| setState(2470); | |
| _errHandler.sync(this); | |
| _alt = getInterpreter().adaptivePredict(_input,216,_ctx); | |
| } | |
| setState(2471); | |
| rpTagEnd(); | |
| } | |
| } | |
| catch (RecognitionException re) { | |
| _localctx.exception = re; | |
| _errHandler.reportError(this, re); | |
| _errHandler.recover(this, re); | |
| } | |
| finally { | |
| exitRule(); | |
| } | |
| return _localctx; | |
| } | |
| public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { | |
| switch (ruleIndex) { | |
| case 0: | |
| return javadoc_sempred((JavadocContext)_localctx, predIndex); | |
| case 5: | |
| return htmlTag_sempred((HtmlTagContext)_localctx, predIndex); | |
| case 8: | |
| return paragraph_sempred((ParagraphContext)_localctx, predIndex); | |
| case 11: | |
| return li_sempred((LiContext)_localctx, predIndex); | |
| case 14: | |
| return tr_sempred((TrContext)_localctx, predIndex); | |
| case 17: | |
| return td_sempred((TdContext)_localctx, predIndex); | |
| case 20: | |
| return th_sempred((ThContext)_localctx, predIndex); | |
| case 23: | |
| return body_sempred((BodyContext)_localctx, predIndex); | |
| case 26: | |
| return colgroup_sempred((ColgroupContext)_localctx, predIndex); | |
| case 29: | |
| return dd_sempred((DdContext)_localctx, predIndex); | |
| case 32: | |
| return dt_sempred((DtContext)_localctx, predIndex); | |
| case 35: | |
| return head_sempred((HeadContext)_localctx, predIndex); | |
| case 38: | |
| return html_sempred((HtmlContext)_localctx, predIndex); | |
| case 41: | |
| return option_sempred((OptionContext)_localctx, predIndex); | |
| case 44: | |
| return tbody_sempred((TbodyContext)_localctx, predIndex); | |
| case 47: | |
| return tfoot_sempred((TfootContext)_localctx, predIndex); | |
| case 50: | |
| return thead_sempred((TheadContext)_localctx, predIndex); | |
| case 68: | |
| return description_sempred((DescriptionContext)_localctx, predIndex); | |
| case 71: | |
| return javadocTag_sempred((JavadocTagContext)_localctx, predIndex); | |
| case 82: | |
| return optgroup_sempred((OptgroupContext)_localctx, predIndex); | |
| case 85: | |
| return rb_sempred((RbContext)_localctx, predIndex); | |
| case 88: | |
| return rt_sempred((RtContext)_localctx, predIndex); | |
| case 91: | |
| return rtc_sempred((RtcContext)_localctx, predIndex); | |
| case 94: | |
| return rp_sempred((RpContext)_localctx, predIndex); | |
| } | |
| return true; | |
| } | |
| private boolean javadoc_sempred(JavadocContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 0: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean htmlTag_sempred(HtmlTagContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 1: | |
| return !isNextJavadocTag(); | |
| case 2: | |
| return isSameTagNames(((HtmlTagContext)_localctx).htmlElementStart, ((HtmlTagContext)_localctx).htmlElementEnd); | |
| } | |
| return true; | |
| } | |
| private boolean paragraph_sempred(ParagraphContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 3: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean li_sempred(LiContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 4: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean tr_sempred(TrContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 5: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean td_sempred(TdContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 6: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean th_sempred(ThContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 7: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean body_sempred(BodyContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 8: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean colgroup_sempred(ColgroupContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 9: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean dd_sempred(DdContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 10: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean dt_sempred(DtContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 11: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean head_sempred(HeadContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 12: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean html_sempred(HtmlContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 13: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean option_sempred(OptionContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 14: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean tbody_sempred(TbodyContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 15: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean tfoot_sempred(TfootContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 16: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean thead_sempred(TheadContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 17: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean description_sempred(DescriptionContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 18: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean javadocTag_sempred(JavadocTagContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 19: | |
| return !isNextJavadocTag(); | |
| case 20: | |
| return !isNextJavadocTag(); | |
| case 21: | |
| return !isNextJavadocTag(); | |
| case 22: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean optgroup_sempred(OptgroupContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 23: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean rb_sempred(RbContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 24: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean rt_sempred(RtContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 25: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean rtc_sempred(RtcContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 26: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private boolean rp_sempred(RpContext _localctx, int predIndex) { | |
| switch (predIndex) { | |
| case 27: | |
| return !isNextJavadocTag(); | |
| } | |
| return true; | |
| } | |
| private static final String _serializedATNSegment0 = | |
| "\u0004\u0001e\u09aa\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+ | |
| "\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+ | |
| "\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+ | |
| "\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+ | |
| "\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f"+ | |
| "\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007\u0012"+ | |
| "\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007\u0015"+ | |
| "\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007\u0018"+ | |
| "\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007\u001b"+ | |
| "\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007\u001e"+ | |
| "\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007\"\u0002"+ | |
| "#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007\'\u0002"+ | |
| "(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007,\u0002"+ | |
| "-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u00071\u0002"+ | |
| "2\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u00076\u0002"+ | |
| "7\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007;\u0002"+ | |
| "<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007@\u0002"+ | |
| "A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007E\u0002"+ | |
| "F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007J\u0002"+ | |
| "K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007O\u0002"+ | |
| "P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007T\u0002"+ | |
| "U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007Y\u0002"+ | |
| "Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007^\u0001"+ | |
| "\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001"+ | |
| "\u0000\u0005\u0000\u00c6\b\u0000\n\u0000\f\u0000\u00c9\t\u0000\u0001\u0000"+ | |
| "\u0003\u0000\u00cc\b\u0000\u0001\u0000\u0005\u0000\u00cf\b\u0000\n\u0000"+ | |
| "\f\u0000\u00d2\t\u0000\u0001\u0000\u0005\u0000\u00d5\b\u0000\n\u0000\f"+ | |
| "\u0000\u00d8\t\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001"+ | |
| "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ | |
| "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ | |
| "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ | |
| "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ | |
| "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ | |
| "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ | |
| "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ | |
| "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ | |
| "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001"+ | |
| "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0003"+ | |
| "\u0001\u011a\b\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001"+ | |
| "\u0002\u0001\u0002\u0005\u0002\u0122\b\u0002\n\u0002\f\u0002\u0125\t\u0002"+ | |
| "\u0001\u0002\u0001\u0002\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003"+ | |
| "\u0005\u0003\u012d\b\u0003\n\u0003\f\u0003\u0130\t\u0003\u0001\u0003\u0001"+ | |
| "\u0003\u0001\u0004\u0001\u0004\u0005\u0004\u0136\b\u0004\n\u0004\f\u0004"+ | |
| "\u0139\t\u0004\u0001\u0004\u0001\u0004\u0005\u0004\u013d\b\u0004\n\u0004"+ | |
| "\f\u0004\u0140\t\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0003\u0004"+ | |
| "\u0145\b\u0004\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005"+ | |
| "\u0001\u0005\u0001\u0005\u0001\u0005\u0005\u0005\u014f\b\u0005\n\u0005"+ | |
| "\f\u0005\u0152\t\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0006"+ | |
| "\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0005\u0006"+ | |
| "\u015d\b\u0006\n\u0006\f\u0006\u0160\t\u0006\u0001\u0006\u0001\u0006\u0001"+ | |
| "\u0007\u0001\u0007\u0001\u0007\u0001\u0007\u0005\u0007\u0168\b\u0007\n"+ | |
| "\u0007\f\u0007\u016b\t\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0001"+ | |
| "\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+ | |
| "\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+ | |
| "\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+ | |
| "\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+ | |
| "\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0001\b\u0005"+ | |
| "\b\u019e\b\b\n\b\f\b\u01a1\t\b\u0001\b\u0001\b\u0001\t\u0001\t\u0001\t"+ | |
| "\u0001\t\u0001\t\u0001\t\u0005\t\u01ab\b\t\n\t\f\t\u01ae\t\t\u0001\t\u0001"+ | |
| "\t\u0001\n\u0001\n\u0001\n\u0001\n\u0005\n\u01b6\b\n\n\n\f\n\u01b9\t\n"+ | |
| "\u0001\n\u0001\n\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ | |
| "\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ | |
| "\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ | |
| "\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ | |
| "\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ | |
| "\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ | |
| "\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ | |
| "\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001"+ | |
| "\u000b\u0005\u000b\u01ec\b\u000b\n\u000b\f\u000b\u01ef\t\u000b\u0001\u000b"+ | |
| "\u0001\u000b\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0001\f\u0005\f\u01f9"+ | |
| "\b\f\n\f\f\f\u01fc\t\f\u0001\f\u0001\f\u0001\r\u0001\r\u0001\r\u0001\r"+ | |
| "\u0005\r\u0204\b\r\n\r\f\r\u0207\t\r\u0001\r\u0001\r\u0001\u000e\u0001"+ | |
| "\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+ | |
| "\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+ | |
| "\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+ | |
| "\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+ | |
| "\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+ | |
| "\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+ | |
| "\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+ | |
| "\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0005\u000e\u023a\b\u000e\n"+ | |
| "\u000e\f\u000e\u023d\t\u000e\u0001\u000e\u0001\u000e\u0001\u000f\u0001"+ | |
| "\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0005\u000f\u0247"+ | |
| "\b\u000f\n\u000f\f\u000f\u024a\t\u000f\u0001\u000f\u0001\u000f\u0001\u0010"+ | |
| "\u0001\u0010\u0001\u0010\u0001\u0010\u0005\u0010\u0252\b\u0010\n\u0010"+ | |
| "\f\u0010\u0255\t\u0010\u0001\u0010\u0001\u0010\u0001\u0011\u0001\u0011"+ | |
| "\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011"+ | |
| "\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011"+ | |
| "\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011"+ | |
| "\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011"+ | |
| "\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011"+ | |
| "\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011"+ | |
| "\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011"+ | |
| "\u0001\u0011\u0001\u0011\u0001\u0011\u0005\u0011\u0288\b\u0011\n\u0011"+ | |
| "\f\u0011\u028b\t\u0011\u0001\u0011\u0001\u0011\u0001\u0012\u0001\u0012"+ | |
| "\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0005\u0012\u0295\b\u0012"+ | |
| "\n\u0012\f\u0012\u0298\t\u0012\u0001\u0012\u0001\u0012\u0001\u0013\u0001"+ | |
| "\u0013\u0001\u0013\u0001\u0013\u0005\u0013\u02a0\b\u0013\n\u0013\f\u0013"+ | |
| "\u02a3\t\u0013\u0001\u0013\u0001\u0013\u0001\u0014\u0001\u0014\u0001\u0014"+ | |
| "\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+ | |
| "\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+ | |
| "\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+ | |
| "\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+ | |
| "\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+ | |
| "\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+ | |
| "\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+ | |
| "\u0001\u0014\u0001\u0014\u0005\u0014\u02d6\b\u0014\n\u0014\f\u0014\u02d9"+ | |
| "\t\u0014\u0001\u0014\u0001\u0014\u0001\u0015\u0001\u0015\u0001\u0015\u0001"+ | |
| "\u0015\u0001\u0015\u0001\u0015\u0005\u0015\u02e3\b\u0015\n\u0015\f\u0015"+ | |
| "\u02e6\t\u0015\u0001\u0015\u0001\u0015\u0001\u0016\u0001\u0016\u0001\u0016"+ | |
| "\u0001\u0016\u0005\u0016\u02ee\b\u0016\n\u0016\f\u0016\u02f1\t\u0016\u0001"+ | |
| "\u0016\u0001\u0016\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001"+ | |
| "\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001"+ | |
| "\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001"+ | |
| "\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001"+ | |
| "\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001"+ | |
| "\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001"+ | |
| "\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001"+ | |
| "\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001"+ | |
| "\u0017\u0005\u0017\u0324\b\u0017\n\u0017\f\u0017\u0327\t\u0017\u0001\u0017"+ | |
| "\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0018"+ | |
| "\u0001\u0018\u0005\u0018\u0331\b\u0018\n\u0018\f\u0018\u0334\t\u0018\u0001"+ | |
| "\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0005"+ | |
| "\u0019\u033c\b\u0019\n\u0019\f\u0019\u033f\t\u0019\u0001\u0019\u0001\u0019"+ | |
| "\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+ | |
| "\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+ | |
| "\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+ | |
| "\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+ | |
| "\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+ | |
| "\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+ | |
| "\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a"+ | |
| "\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001a\u0005\u001a"+ | |
| "\u0372\b\u001a\n\u001a\f\u001a\u0375\t\u001a\u0001\u001a\u0001\u001a\u0001"+ | |
| "\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0005"+ | |
| "\u001b\u037f\b\u001b\n\u001b\f\u001b\u0382\t\u001b\u0001\u001b\u0001\u001b"+ | |
| "\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0005\u001c\u038a\b\u001c"+ | |
| "\n\u001c\f\u001c\u038d\t\u001c\u0001\u001c\u0001\u001c\u0001\u001d\u0001"+ | |
| "\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+ | |
| "\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+ | |
| "\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+ | |
| "\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+ | |
| "\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+ | |
| "\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+ | |
| "\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001"+ | |
| "\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0005\u001d\u03c0\b\u001d\n"+ | |
| "\u001d\f\u001d\u03c3\t\u001d\u0001\u001d\u0001\u001d\u0001\u001e\u0001"+ | |
| "\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0005\u001e\u03cd"+ | |
| "\b\u001e\n\u001e\f\u001e\u03d0\t\u001e\u0001\u001e\u0001\u001e\u0001\u001f"+ | |
| "\u0001\u001f\u0001\u001f\u0001\u001f\u0005\u001f\u03d8\b\u001f\n\u001f"+ | |
| "\f\u001f\u03db\t\u001f\u0001\u001f\u0001\u001f\u0001 \u0001 \u0001 \u0001"+ | |
| " \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001"+ | |
| " \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001"+ | |
| " \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001"+ | |
| " \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001 \u0001"+ | |
| " \u0001 \u0001 \u0001 \u0005 \u040e\b \n \f \u0411\t \u0001 \u0001 \u0001"+ | |
| "!\u0001!\u0001!\u0001!\u0001!\u0001!\u0005!\u041b\b!\n!\f!\u041e\t!\u0001"+ | |
| "!\u0001!\u0001\"\u0001\"\u0001\"\u0001\"\u0005\"\u0426\b\"\n\"\f\"\u0429"+ | |
| "\t\"\u0001\"\u0001\"\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#"+ | |
| "\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001"+ | |
| "#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001"+ | |
| "#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001"+ | |
| "#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001"+ | |
| "#\u0005#\u045c\b#\n#\f#\u045f\t#\u0001#\u0001#\u0001$\u0001$\u0001$\u0001"+ | |
| "$\u0001$\u0001$\u0005$\u0469\b$\n$\f$\u046c\t$\u0001$\u0001$\u0001%\u0001"+ | |
| "%\u0001%\u0001%\u0005%\u0474\b%\n%\f%\u0477\t%\u0001%\u0001%\u0001&\u0001"+ | |
| "&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001"+ | |
| "&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001"+ | |
| "&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001"+ | |
| "&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001"+ | |
| "&\u0001&\u0001&\u0001&\u0001&\u0001&\u0005&\u04aa\b&\n&\f&\u04ad\t&\u0001"+ | |
| "&\u0001&\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0005\'\u04b7"+ | |
| "\b\'\n\'\f\'\u04ba\t\'\u0001\'\u0001\'\u0001(\u0001(\u0001(\u0001(\u0005"+ | |
| "(\u04c2\b(\n(\f(\u04c5\t(\u0001(\u0001(\u0001)\u0001)\u0001)\u0001)\u0001"+ | |
| ")\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001"+ | |
| ")\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001"+ | |
| ")\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001"+ | |
| ")\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001"+ | |
| ")\u0001)\u0001)\u0005)\u04f8\b)\n)\f)\u04fb\t)\u0001)\u0001)\u0001*\u0001"+ | |
| "*\u0001*\u0001*\u0001*\u0001*\u0005*\u0505\b*\n*\f*\u0508\t*\u0001*\u0001"+ | |
| "*\u0001+\u0001+\u0001+\u0001+\u0005+\u0510\b+\n+\f+\u0513\t+\u0001+\u0001"+ | |
| "+\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+ | |
| ",\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+ | |
| ",\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+ | |
| ",\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001"+ | |
| ",\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0005,\u0546\b,\n,"+ | |
| "\f,\u0549\t,\u0001,\u0001,\u0001-\u0001-\u0001-\u0001-\u0001-\u0001-\u0005"+ | |
| "-\u0553\b-\n-\f-\u0556\t-\u0001-\u0001-\u0001.\u0001.\u0001.\u0001.\u0005"+ | |
| ".\u055e\b.\n.\f.\u0561\t.\u0001.\u0001.\u0001/\u0001/\u0001/\u0001/\u0001"+ | |
| "/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001"+ | |
| "/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001"+ | |
| "/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001"+ | |
| "/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001/\u0001"+ | |
| "/\u0001/\u0001/\u0005/\u0594\b/\n/\f/\u0597\t/\u0001/\u0001/\u00010\u0001"+ | |
| "0\u00010\u00010\u00010\u00010\u00050\u05a1\b0\n0\f0\u05a4\t0\u00010\u0001"+ | |
| "0\u00011\u00011\u00011\u00011\u00051\u05ac\b1\n1\f1\u05af\t1\u00011\u0001"+ | |
| "1\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u0001"+ | |
| "2\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u0001"+ | |
| "2\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u0001"+ | |
| "2\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u0001"+ | |
| "2\u00012\u00012\u00012\u00012\u00012\u00012\u00012\u00052\u05e2\b2\n2"+ | |
| "\f2\u05e5\t2\u00012\u00012\u00013\u00013\u00013\u00013\u00013\u00013\u0001"+ | |
| "3\u00013\u00013\u00013\u00013\u00013\u00013\u00013\u00013\u00013\u0001"+ | |
| "3\u00013\u00013\u00013\u00033\u05fd\b3\u00014\u00014\u00014\u00014\u0001"+ | |
| "4\u00014\u00054\u0605\b4\n4\f4\u0608\t4\u00014\u00014\u00015\u00015\u0001"+ | |
| "5\u00015\u00015\u00015\u00055\u0612\b5\n5\f5\u0615\t5\u00015\u00015\u0001"+ | |
| "6\u00016\u00016\u00016\u00016\u00016\u00056\u061f\b6\n6\f6\u0622\t6\u0001"+ | |
| "6\u00016\u00017\u00017\u00017\u00017\u00017\u00017\u00057\u062c\b7\n7"+ | |
| "\f7\u062f\t7\u00017\u00017\u00018\u00018\u00018\u00018\u00018\u00018\u0005"+ | |
| "8\u0639\b8\n8\f8\u063c\t8\u00018\u00018\u00019\u00019\u00019\u00019\u0001"+ | |
| "9\u00019\u00059\u0646\b9\n9\f9\u0649\t9\u00019\u00019\u0001:\u0001:\u0001"+ | |
| ":\u0001:\u0001:\u0001:\u0005:\u0653\b:\n:\f:\u0656\t:\u0001:\u0001:\u0001"+ | |
| ";\u0001;\u0001;\u0001;\u0001;\u0001;\u0005;\u0660\b;\n;\f;\u0663\t;\u0001"+ | |
| ";\u0001;\u0001<\u0001<\u0001<\u0001<\u0001<\u0001<\u0005<\u066d\b<\n<"+ | |
| "\f<\u0670\t<\u0001<\u0001<\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0005"+ | |
| "=\u067a\b=\n=\f=\u067d\t=\u0001=\u0001=\u0001>\u0001>\u0001>\u0001>\u0001"+ | |
| ">\u0001>\u0005>\u0687\b>\n>\f>\u068a\t>\u0001>\u0001>\u0001?\u0001?\u0001"+ | |
| "?\u0001?\u0001?\u0001?\u0005?\u0694\b?\n?\f?\u0697\t?\u0001?\u0001?\u0001"+ | |
| "@\u0001@\u0001@\u0001@\u0001@\u0001@\u0005@\u06a1\b@\n@\f@\u06a4\t@\u0001"+ | |
| "@\u0001@\u0001A\u0001A\u0001A\u0001A\u0001A\u0001A\u0005A\u06ae\bA\nA"+ | |
| "\fA\u06b1\tA\u0001A\u0001A\u0001B\u0001B\u0001B\u0001B\u0001B\u0001B\u0001"+ | |
| "C\u0001C\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0004D\u06c4"+ | |
| "\bD\u000bD\fD\u06c5\u0001E\u0001E\u0001E\u0001E\u0003E\u06cc\bE\u0003"+ | |
| "E\u06ce\bE\u0001E\u0001E\u0001E\u0003E\u06d3\bE\u0003E\u06d5\bE\u0001"+ | |
| "F\u0001F\u0005F\u06d9\bF\nF\fF\u06dc\tF\u0001F\u0001F\u0001G\u0001G\u0004"+ | |
| "G\u06e2\bG\u000bG\fG\u06e3\u0001G\u0001G\u0001G\u0005G\u06e9\bG\nG\fG"+ | |
| "\u06ec\tG\u0001G\u0001G\u0003G\u06f0\bG\u0001G\u0001G\u0001G\u0001G\u0001"+ | |
| "G\u0004G\u06f7\bG\u000bG\fG\u06f8\u0001G\u0001G\u0005G\u06fd\bG\nG\fG"+ | |
| "\u0700\tG\u0001G\u0001G\u0003G\u0704\bG\u0001G\u0001G\u0001G\u0001G\u0001"+ | |
| "G\u0004G\u070b\bG\u000bG\fG\u070c\u0001G\u0001G\u0005G\u0711\bG\nG\fG"+ | |
| "\u0714\tG\u0001G\u0001G\u0003G\u0718\bG\u0001G\u0001G\u0004G\u071c\bG"+ | |
| "\u000bG\fG\u071d\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0004G\u0726"+ | |
| "\bG\u000bG\fG\u0727\u0001G\u0001G\u0001G\u0003G\u072d\bG\u0001G\u0005"+ | |
| "G\u0730\bG\nG\fG\u0733\tG\u0001G\u0001G\u0003G\u0737\bG\u0001G\u0001G"+ | |
| "\u0005G\u073b\bG\nG\fG\u073e\tG\u0001G\u0001G\u0001G\u0001G\u0003G\u0744"+ | |
| "\bG\u0001G\u0005G\u0747\bG\nG\fG\u074a\tG\u0001G\u0001G\u0005G\u074e\b"+ | |
| "G\nG\fG\u0751\tG\u0001G\u0001G\u0003G\u0755\bG\u0001G\u0001G\u0005G\u0759"+ | |
| "\bG\nG\fG\u075c\tG\u0001G\u0001G\u0003G\u0760\bG\u0001G\u0005G\u0763\b"+ | |
| "G\nG\fG\u0766\tG\u0001G\u0001G\u0003G\u076a\bG\u0001G\u0005G\u076d\bG"+ | |
| "\nG\fG\u0770\tG\u0001G\u0001G\u0003G\u0774\bG\u0001G\u0001G\u0004G\u0778"+ | |
| "\bG\u000bG\fG\u0779\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0004G\u0782"+ | |
| "\bG\u000bG\fG\u0783\u0001G\u0001G\u0005G\u0788\bG\nG\fG\u078b\tG\u0001"+ | |
| "G\u0001G\u0003G\u078f\bG\u0001G\u0001G\u0004G\u0793\bG\u000bG\fG\u0794"+ | |
| "\u0001G\u0001G\u0001G\u0005G\u079a\bG\nG\fG\u079d\tG\u0001G\u0001G\u0003"+ | |
| "G\u07a1\bG\u0003G\u07a3\bG\u0001H\u0001H\u0001H\u0001H\u0001H\u0001H\u0005"+ | |
| "H\u07ab\bH\nH\fH\u07ae\tH\u0001H\u0001H\u0005H\u07b2\bH\nH\fH\u07b5\t"+ | |
| "H\u0001H\u0001H\u0005H\u07b9\bH\nH\fH\u07bc\tH\u0001H\u0001H\u0004H\u07c0"+ | |
| "\bH\u000bH\fH\u07c1\u0001H\u0001H\u0005H\u07c6\bH\nH\fH\u07c9\tH\u0001"+ | |
| "H\u0001H\u0003H\u07cd\bH\u0001H\u0001H\u0004H\u07d1\bH\u000bH\fH\u07d2"+ | |
| "\u0001H\u0001H\u0005H\u07d7\bH\nH\fH\u07da\tH\u0001H\u0001H\u0003H\u07de"+ | |
| "\bH\u0001H\u0001H\u0001H\u0001H\u0001H\u0005H\u07e5\bH\nH\fH\u07e8\tH"+ | |
| "\u0001H\u0001H\u0005H\u07ec\bH\nH\fH\u07ef\tH\u0001H\u0001H\u0003H\u07f3"+ | |
| "\bH\u0001H\u0001H\u0005H\u07f7\bH\nH\fH\u07fa\tH\u0001H\u0001H\u0003H"+ | |
| "\u07fe\bH\u0003H\u0800\bH\u0001H\u0001H\u0001I\u0001I\u0001I\u0001I\u0005"+ | |
| "I\u0808\bI\nI\fI\u080b\tI\u0001I\u0001I\u0001J\u0001J\u0004J\u0811\bJ"+ | |
| "\u000bJ\fJ\u0812\u0001K\u0001K\u0001K\u0001K\u0001K\u0001K\u0005K\u081b"+ | |
| "\bK\nK\fK\u081e\tK\u0001K\u0001K\u0001L\u0001L\u0001L\u0001L\u0001L\u0001"+ | |
| "L\u0005L\u0828\bL\nL\fL\u082b\tL\u0001L\u0001L\u0001M\u0001M\u0001M\u0001"+ | |
| "M\u0001M\u0001M\u0005M\u0835\bM\nM\fM\u0838\tM\u0001M\u0001M\u0001N\u0001"+ | |
| "N\u0001N\u0001N\u0001N\u0001N\u0005N\u0842\bN\nN\fN\u0845\tN\u0001N\u0001"+ | |
| "N\u0001O\u0001O\u0001O\u0001O\u0001O\u0001O\u0005O\u084f\bO\nO\fO\u0852"+ | |
| "\tO\u0001O\u0001O\u0001P\u0001P\u0001P\u0001P\u0001P\u0001P\u0005P\u085c"+ | |
| "\bP\nP\fP\u085f\tP\u0001P\u0001P\u0001Q\u0001Q\u0001Q\u0001Q\u0005Q\u0867"+ | |
| "\bQ\nQ\fQ\u086a\tQ\u0001Q\u0001Q\u0001R\u0001R\u0001R\u0001R\u0001R\u0001"+ | |
| "R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001"+ | |
| "R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001"+ | |
| "R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001R\u0001"+ | |
| "R\u0001R\u0005R\u0893\bR\nR\fR\u0896\tR\u0001R\u0001R\u0001S\u0001S\u0001"+ | |
| "S\u0001S\u0001S\u0001S\u0005S\u08a0\bS\nS\fS\u08a3\tS\u0001S\u0001S\u0001"+ | |
| "T\u0001T\u0001T\u0001T\u0005T\u08ab\bT\nT\fT\u08ae\tT\u0001T\u0001T\u0001"+ | |
| "U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001"+ | |
| "U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001"+ | |
| "U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001"+ | |
| "U\u0001U\u0001U\u0001U\u0001U\u0001U\u0001U\u0005U\u08d7\bU\nU\fU\u08da"+ | |
| "\tU\u0001U\u0001U\u0001V\u0001V\u0001V\u0001V\u0001V\u0001V\u0005V\u08e4"+ | |
| "\bV\nV\fV\u08e7\tV\u0001V\u0001V\u0001W\u0001W\u0001W\u0001W\u0005W\u08ef"+ | |
| "\bW\nW\fW\u08f2\tW\u0001W\u0001W\u0001X\u0001X\u0001X\u0001X\u0001X\u0001"+ | |
| "X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001"+ | |
| "X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001"+ | |
| "X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001X\u0001"+ | |
| "X\u0001X\u0005X\u091b\bX\nX\fX\u091e\tX\u0001X\u0001X\u0001Y\u0001Y\u0001"+ | |
| "Y\u0001Y\u0001Y\u0001Y\u0005Y\u0928\bY\nY\fY\u092b\tY\u0001Y\u0001Y\u0001"+ | |
| "Z\u0001Z\u0001Z\u0001Z\u0005Z\u0933\bZ\nZ\fZ\u0936\tZ\u0001Z\u0001Z\u0001"+ | |
| "[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001"+ | |
| "[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001"+ | |
| "[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001"+ | |
| "[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0005[\u095f\b[\n[\f[\u0962"+ | |
| "\t[\u0001[\u0001[\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0005"+ | |
| "\\\u096c\b\\\n\\\f\\\u096f\t\\\u0001\\\u0001\\\u0001]\u0001]\u0001]\u0001"+ | |
| "]\u0005]\u0977\b]\n]\f]\u097a\t]\u0001]\u0001]\u0001^\u0001^\u0001^\u0001"+ | |
| "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ | |
| "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ | |
| "^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001"+ | |
| "^\u0001^\u0001^\u0001^\u0005^\u09a3\b^\n^\f^\u09a6\t^\u0001^\u0001^\u0001"+ | |
| "^\u0000\u0000_\u0000\u0002\u0004\u0006\b\n\f\u000e\u0010\u0012\u0014\u0016"+ | |
| "\u0018\u001a\u001c\u001e \"$&(*,.02468:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprt"+ | |
| "vxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094"+ | |
| "\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac"+ | |
| "\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u0000\u0007\u0003\u0000"+ | |
| "\u0001\u0001\u0004\u0004\u0006\u0006\u0002\u0000;Idd\u0001\u000078\u0002"+ | |
| "\u0000JX\\^\u0004\u0000\u0001\u0001\u0004\u0004\u0006\u0006$%\u0002\u0000"+ | |
| "\u0004\u0004\u0006\u0006\u0002\u0000\u0004\u0004\u0018\u0018\u0e15\u0000"+ | |
| "\u00c7\u0001\u0000\u0000\u0000\u0002\u0119\u0001\u0000\u0000\u0000\u0004"+ | |
| "\u011b\u0001\u0000\u0000\u0000\u0006\u0128\u0001\u0000\u0000\u0000\b\u0133"+ | |
| "\u0001\u0000\u0000\u0000\n\u0146\u0001\u0000\u0000\u0000\f\u0156\u0001"+ | |
| "\u0000\u0000\u0000\u000e\u0163\u0001\u0000\u0000\u0000\u0010\u016e\u0001"+ | |
| "\u0000\u0000\u0000\u0012\u01a4\u0001\u0000\u0000\u0000\u0014\u01b1\u0001"+ | |
| "\u0000\u0000\u0000\u0016\u01bc\u0001\u0000\u0000\u0000\u0018\u01f2\u0001"+ | |
| "\u0000\u0000\u0000\u001a\u01ff\u0001\u0000\u0000\u0000\u001c\u020a\u0001"+ | |
| "\u0000\u0000\u0000\u001e\u0240\u0001\u0000\u0000\u0000 \u024d\u0001\u0000"+ | |
| "\u0000\u0000\"\u0258\u0001\u0000\u0000\u0000$\u028e\u0001\u0000\u0000"+ | |
| "\u0000&\u029b\u0001\u0000\u0000\u0000(\u02a6\u0001\u0000\u0000\u0000*"+ | |
| "\u02dc\u0001\u0000\u0000\u0000,\u02e9\u0001\u0000\u0000\u0000.\u02f4\u0001"+ | |
| "\u0000\u0000\u00000\u032a\u0001\u0000\u0000\u00002\u0337\u0001\u0000\u0000"+ | |
| "\u00004\u0342\u0001\u0000\u0000\u00006\u0378\u0001\u0000\u0000\u00008"+ | |
| "\u0385\u0001\u0000\u0000\u0000:\u0390\u0001\u0000\u0000\u0000<\u03c6\u0001"+ | |
| "\u0000\u0000\u0000>\u03d3\u0001\u0000\u0000\u0000@\u03de\u0001\u0000\u0000"+ | |
| "\u0000B\u0414\u0001\u0000\u0000\u0000D\u0421\u0001\u0000\u0000\u0000F"+ | |
| "\u042c\u0001\u0000\u0000\u0000H\u0462\u0001\u0000\u0000\u0000J\u046f\u0001"+ | |
| "\u0000\u0000\u0000L\u047a\u0001\u0000\u0000\u0000N\u04b0\u0001\u0000\u0000"+ | |
| "\u0000P\u04bd\u0001\u0000\u0000\u0000R\u04c8\u0001\u0000\u0000\u0000T"+ | |
| "\u04fe\u0001\u0000\u0000\u0000V\u050b\u0001\u0000\u0000\u0000X\u0516\u0001"+ | |
| "\u0000\u0000\u0000Z\u054c\u0001\u0000\u0000\u0000\\\u0559\u0001\u0000"+ | |
| "\u0000\u0000^\u0564\u0001\u0000\u0000\u0000`\u059a\u0001\u0000\u0000\u0000"+ | |
| "b\u05a7\u0001\u0000\u0000\u0000d\u05b2\u0001\u0000\u0000\u0000f\u05fc"+ | |
| "\u0001\u0000\u0000\u0000h\u05fe\u0001\u0000\u0000\u0000j\u060b\u0001\u0000"+ | |
| "\u0000\u0000l\u0618\u0001\u0000\u0000\u0000n\u0625\u0001\u0000\u0000\u0000"+ | |
| "p\u0632\u0001\u0000\u0000\u0000r\u063f\u0001\u0000\u0000\u0000t\u064c"+ | |
| "\u0001\u0000\u0000\u0000v\u0659\u0001\u0000\u0000\u0000x\u0666\u0001\u0000"+ | |
| "\u0000\u0000z\u0673\u0001\u0000\u0000\u0000|\u0680\u0001\u0000\u0000\u0000"+ | |
| "~\u068d\u0001\u0000\u0000\u0000\u0080\u069a\u0001\u0000\u0000\u0000\u0082"+ | |
| "\u06a7\u0001\u0000\u0000\u0000\u0084\u06b4\u0001\u0000\u0000\u0000\u0086"+ | |
| "\u06ba\u0001\u0000\u0000\u0000\u0088\u06c3\u0001\u0000\u0000\u0000\u008a"+ | |
| "\u06d4\u0001\u0000\u0000\u0000\u008c\u06d6\u0001\u0000\u0000\u0000\u008e"+ | |
| "\u07a2\u0001\u0000\u0000\u0000\u0090\u07a4\u0001\u0000\u0000\u0000\u0092"+ | |
| "\u0803\u0001\u0000\u0000\u0000\u0094\u0810\u0001\u0000\u0000\u0000\u0096"+ | |
| "\u0814\u0001\u0000\u0000\u0000\u0098\u0821\u0001\u0000\u0000\u0000\u009a"+ | |
| "\u082e\u0001\u0000\u0000\u0000\u009c\u083b\u0001\u0000\u0000\u0000\u009e"+ | |
| "\u0848\u0001\u0000\u0000\u0000\u00a0\u0855\u0001\u0000\u0000\u0000\u00a2"+ | |
| "\u0862\u0001\u0000\u0000\u0000\u00a4\u086d\u0001\u0000\u0000\u0000\u00a6"+ | |
| "\u0899\u0001\u0000\u0000\u0000\u00a8\u08a6\u0001\u0000\u0000\u0000\u00aa"+ | |
| "\u08b1\u0001\u0000\u0000\u0000\u00ac\u08dd\u0001\u0000\u0000\u0000\u00ae"+ | |
| "\u08ea\u0001\u0000\u0000\u0000\u00b0\u08f5\u0001\u0000\u0000\u0000\u00b2"+ | |
| "\u0921\u0001\u0000\u0000\u0000\u00b4\u092e\u0001\u0000\u0000\u0000\u00b6"+ | |
| "\u0939\u0001\u0000\u0000\u0000\u00b8\u0965\u0001\u0000\u0000\u0000\u00ba"+ | |
| "\u0972\u0001\u0000\u0000\u0000\u00bc\u097d\u0001\u0000\u0000\u0000\u00be"+ | |
| "\u00c6\u0003\u0002\u0001\u0000\u00bf\u00c0\u0004\u0000\u0000\u0000\u00c0"+ | |
| "\u00c6\u0005\u0001\u0000\u0000\u00c1\u00c6\u0003\u0092I\u0000\u00c2\u00c6"+ | |
| "\u0005\u0006\u0000\u0000\u00c3\u00c6\u0003\u0094J\u0000\u00c4\u00c6\u0003"+ | |
| "\u0090H\u0000\u00c5\u00be\u0001\u0000\u0000\u0000\u00c5\u00bf\u0001\u0000"+ | |
| "\u0000\u0000\u00c5\u00c1\u0001\u0000\u0000\u0000\u00c5\u00c2\u0001\u0000"+ | |
| "\u0000\u0000\u00c5\u00c3\u0001\u0000\u0000\u0000\u00c5\u00c4\u0001\u0000"+ | |
| "\u0000\u0000\u00c6\u00c9\u0001\u0000\u0000\u0000\u00c7\u00c5\u0001\u0000"+ | |
| "\u0000\u0000\u00c7\u00c8\u0001\u0000\u0000\u0000\u00c8\u00d6\u0001\u0000"+ | |
| "\u0000\u0000\u00c9\u00c7\u0001\u0000\u0000\u0000\u00ca\u00cc\u0005\u0001"+ | |
| "\u0000\u0000\u00cb\u00ca\u0001\u0000\u0000\u0000\u00cb\u00cc\u0001\u0000"+ | |
| "\u0000\u0000\u00cc\u00d0\u0001\u0000\u0000\u0000\u00cd\u00cf\u0005\u0004"+ | |
| "\u0000\u0000\u00ce\u00cd\u0001\u0000\u0000\u0000\u00cf\u00d2\u0001\u0000"+ | |
| "\u0000\u0000\u00d0\u00ce\u0001\u0000\u0000\u0000\u00d0\u00d1\u0001\u0000"+ | |
| "\u0000\u0000\u00d1\u00d3\u0001\u0000\u0000\u0000\u00d2\u00d0\u0001\u0000"+ | |
| "\u0000\u0000\u00d3\u00d5\u0003\u008eG\u0000\u00d4\u00cb\u0001\u0000\u0000"+ | |
| "\u0000\u00d5\u00d8\u0001\u0000\u0000\u0000\u00d6\u00d4\u0001\u0000\u0000"+ | |
| "\u0000\u00d6\u00d7\u0001\u0000\u0000\u0000\u00d7\u00d9\u0001\u0000\u0000"+ | |
| "\u0000\u00d8\u00d6\u0001\u0000\u0000\u0000\u00d9\u00da\u0005\u0000\u0000"+ | |
| "\u0001\u00da\u0001\u0001\u0000\u0000\u0000\u00db\u011a\u0003\n\u0005\u0000"+ | |
| "\u00dc\u011a\u0003f3\u0000\u00dd\u011a\u0003\u0010\b\u0000\u00de\u011a"+ | |
| "\u0003\u0016\u000b\u0000\u00df\u011a\u0003\u001c\u000e\u0000\u00e0\u011a"+ | |
| "\u0003\"\u0011\u0000\u00e1\u011a\u0003(\u0014\u0000\u00e2\u011a\u0003"+ | |
| ".\u0017\u0000\u00e3\u011a\u00034\u001a\u0000\u00e4\u011a\u0003:\u001d"+ | |
| "\u0000\u00e5\u011a\u0003@ \u0000\u00e6\u011a\u0003F#\u0000\u00e7\u011a"+ | |
| "\u0003L&\u0000\u00e8\u011a\u0003R)\u0000\u00e9\u011a\u0003X,\u0000\u00ea"+ | |
| "\u011a\u0003d2\u0000\u00eb\u011a\u0003^/\u0000\u00ec\u011a\u0003\u00a4"+ | |
| "R\u0000\u00ed\u011a\u0003\u00aaU\u0000\u00ee\u011a\u0003\u00b0X\u0000"+ | |
| "\u00ef\u011a\u0003\u00b6[\u0000\u00f0\u011a\u0003\u00bc^\u0000\u00f1\u011a"+ | |
| "\u0003\f\u0006\u0000\u00f2\u011a\u0003\u0012\t\u0000\u00f3\u011a\u0003"+ | |
| "\u0018\f\u0000\u00f4\u011a\u0003\u001e\u000f\u0000\u00f5\u011a\u0003$"+ | |
| "\u0012\u0000\u00f6\u011a\u0003*\u0015\u0000\u00f7\u011a\u00030\u0018\u0000"+ | |
| "\u00f8\u011a\u00036\u001b\u0000\u00f9\u011a\u0003<\u001e\u0000\u00fa\u011a"+ | |
| "\u0003B!\u0000\u00fb\u011a\u0003H$\u0000\u00fc\u011a\u0003N\'\u0000\u00fd"+ | |
| "\u011a\u0003T*\u0000\u00fe\u011a\u0003`0\u0000\u00ff\u011a\u0003Z-\u0000"+ | |
| "\u0100\u011a\u0003\u00a0P\u0000\u0101\u011a\u0003\u00a6S\u0000\u0102\u011a"+ | |
| "\u0003\u00acV\u0000\u0103\u011a\u0003\u00b2Y\u0000\u0104\u011a\u0003\u00b8"+ | |
| "\\\u0000\u0105\u011a\u0003\u000e\u0007\u0000\u0106\u011a\u0003\u0014\n"+ | |
| "\u0000\u0107\u011a\u0003\u001a\r\u0000\u0108\u011a\u0003 \u0010\u0000"+ | |
| "\u0109\u011a\u0003&\u0013\u0000\u010a\u011a\u0003,\u0016\u0000\u010b\u011a"+ | |
| "\u00032\u0019\u0000\u010c\u011a\u00038\u001c\u0000\u010d\u011a\u0003>"+ | |
| "\u001f\u0000\u010e\u011a\u0003D\"\u0000\u010f\u011a\u0003J%\u0000\u0110"+ | |
| "\u011a\u0003P(\u0000\u0111\u011a\u0003V+\u0000\u0112\u011a\u0003b1\u0000"+ | |
| "\u0113\u011a\u0003\\.\u0000\u0114\u011a\u0003\u00a2Q\u0000\u0115\u011a"+ | |
| "\u0003\u00a8T\u0000\u0116\u011a\u0003\u00aeW\u0000\u0117\u011a\u0003\u00b4"+ | |
| "Z\u0000\u0118\u011a\u0003\u00ba]\u0000\u0119\u00db\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00dc\u0001\u0000\u0000\u0000\u0119\u00dd\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00de\u0001\u0000\u0000\u0000\u0119\u00df\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00e0\u0001\u0000\u0000\u0000\u0119\u00e1\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00e2\u0001\u0000\u0000\u0000\u0119\u00e3\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00e4\u0001\u0000\u0000\u0000\u0119\u00e5\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00e6\u0001\u0000\u0000\u0000\u0119\u00e7\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00e8\u0001\u0000\u0000\u0000\u0119\u00e9\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00ea\u0001\u0000\u0000\u0000\u0119\u00eb\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00ec\u0001\u0000\u0000\u0000\u0119\u00ed\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00ee\u0001\u0000\u0000\u0000\u0119\u00ef\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00f0\u0001\u0000\u0000\u0000\u0119\u00f1\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00f2\u0001\u0000\u0000\u0000\u0119\u00f3\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00f4\u0001\u0000\u0000\u0000\u0119\u00f5\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00f6\u0001\u0000\u0000\u0000\u0119\u00f7\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00f8\u0001\u0000\u0000\u0000\u0119\u00f9\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00fa\u0001\u0000\u0000\u0000\u0119\u00fb\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00fc\u0001\u0000\u0000\u0000\u0119\u00fd\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u00fe\u0001\u0000\u0000\u0000\u0119\u00ff\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u0100\u0001\u0000\u0000\u0000\u0119\u0101\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u0102\u0001\u0000\u0000\u0000\u0119\u0103\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u0104\u0001\u0000\u0000\u0000\u0119\u0105\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u0106\u0001\u0000\u0000\u0000\u0119\u0107\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u0108\u0001\u0000\u0000\u0000\u0119\u0109\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u010a\u0001\u0000\u0000\u0000\u0119\u010b\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u010c\u0001\u0000\u0000\u0000\u0119\u010d\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u010e\u0001\u0000\u0000\u0000\u0119\u010f\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u0110\u0001\u0000\u0000\u0000\u0119\u0111\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u0112\u0001\u0000\u0000\u0000\u0119\u0113\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u0114\u0001\u0000\u0000\u0000\u0119\u0115\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u0116\u0001\u0000\u0000\u0000\u0119\u0117\u0001\u0000\u0000\u0000"+ | |
| "\u0119\u0118\u0001\u0000\u0000\u0000\u011a\u0003\u0001\u0000\u0000\u0000"+ | |
| "\u011b\u011c\u0005\u0005\u0000\u0000\u011c\u0123\u0005d\u0000\u0000\u011d"+ | |
| "\u0122\u0003\b\u0004\u0000\u011e\u0122\u0005\u0006\u0000\u0000\u011f\u0122"+ | |
| "\u0005\u0001\u0000\u0000\u0120\u0122\u0005\u0004\u0000\u0000\u0121\u011d"+ | |
| "\u0001\u0000\u0000\u0000\u0121\u011e\u0001\u0000\u0000\u0000\u0121\u011f"+ | |
| "\u0001\u0000\u0000\u0000\u0121\u0120\u0001\u0000\u0000\u0000\u0122\u0125"+ | |
| "\u0001\u0000\u0000\u0000\u0123\u0121\u0001\u0000\u0000\u0000\u0123\u0124"+ | |
| "\u0001\u0000\u0000\u0000\u0124\u0126\u0001\u0000\u0000\u0000\u0125\u0123"+ | |
| "\u0001\u0000\u0000\u0000\u0126\u0127\u00057\u0000\u0000\u0127\u0005\u0001"+ | |
| "\u0000\u0000\u0000\u0128\u0129\u0005\u0005\u0000\u0000\u0129\u012a\u0005"+ | |
| "9\u0000\u0000\u012a\u012e\u0005d\u0000\u0000\u012b\u012d\u0007\u0000\u0000"+ | |
| "\u0000\u012c\u012b\u0001\u0000\u0000\u0000\u012d\u0130\u0001\u0000\u0000"+ | |
| "\u0000\u012e\u012c\u0001\u0000\u0000\u0000\u012e\u012f\u0001\u0000\u0000"+ | |
| "\u0000\u012f\u0131\u0001\u0000\u0000\u0000\u0130\u012e\u0001\u0000\u0000"+ | |
| "\u0000\u0131\u0132\u00057\u0000\u0000\u0132\u0007\u0001\u0000\u0000\u0000"+ | |
| "\u0133\u0137\u0005d\u0000\u0000\u0134\u0136\u0007\u0000\u0000\u0000\u0135"+ | |
| "\u0134\u0001\u0000\u0000\u0000\u0136\u0139\u0001\u0000\u0000\u0000\u0137"+ | |
| "\u0135\u0001\u0000\u0000\u0000\u0137\u0138\u0001\u0000\u0000\u0000\u0138"+ | |
| "\u013a\u0001\u0000\u0000\u0000\u0139\u0137\u0001\u0000\u0000\u0000\u013a"+ | |
| "\u013e\u0005:\u0000\u0000\u013b\u013d\u0007\u0000\u0000\u0000\u013c\u013b"+ | |
| "\u0001\u0000\u0000\u0000\u013d\u0140\u0001\u0000\u0000\u0000\u013e\u013c"+ | |
| "\u0001\u0000\u0000\u0000\u013e\u013f\u0001\u0000\u0000\u0000\u013f\u0144"+ | |
| "\u0001\u0000\u0000\u0000\u0140\u013e\u0001\u0000\u0000\u0000\u0141\u0145"+ | |
| "\u0005Y\u0000\u0000\u0142\u0145\u0003\u0094J\u0000\u0143\u0145\u0005d"+ | |
| "\u0000\u0000\u0144\u0141\u0001\u0000\u0000\u0000\u0144\u0142\u0001\u0000"+ | |
| "\u0000\u0000\u0144\u0143\u0001\u0000\u0000\u0000\u0145\t\u0001\u0000\u0000"+ | |
| "\u0000\u0146\u0150\u0003\u0004\u0002\u0000\u0147\u014f\u0003\u0002\u0001"+ | |
| "\u0000\u0148\u0149\u0004\u0005\u0001\u0000\u0149\u014f\u0005\u0001\u0000"+ | |
| "\u0000\u014a\u014f\u0003\u0092I\u0000\u014b\u014f\u0005\u0006\u0000\u0000"+ | |
| "\u014c\u014f\u0003\u0094J\u0000\u014d\u014f\u0003\u0090H\u0000\u014e\u0147"+ | |
| "\u0001\u0000\u0000\u0000\u014e\u0148\u0001\u0000\u0000\u0000\u014e\u014a"+ | |
| "\u0001\u0000\u0000\u0000\u014e\u014b\u0001\u0000\u0000\u0000\u014e\u014c"+ | |
| "\u0001\u0000\u0000\u0000\u014e\u014d\u0001\u0000\u0000\u0000\u014f\u0152"+ | |
| "\u0001\u0000\u0000\u0000\u0150\u014e\u0001\u0000\u0000\u0000\u0150\u0151"+ | |
| "\u0001\u0000\u0000\u0000\u0151\u0153\u0001\u0000\u0000\u0000\u0152\u0150"+ | |
| "\u0001\u0000\u0000\u0000\u0153\u0154\u0003\u0006\u0003\u0000\u0154\u0155"+ | |
| "\u0004\u0005\u0002\u0001\u0155\u000b\u0001\u0000\u0000\u0000\u0156\u0157"+ | |
| "\u0005\u0005\u0000\u0000\u0157\u015e\u0005;\u0000\u0000\u0158\u015d\u0003"+ | |
| "\b\u0004\u0000\u0159\u015d\u0005\u0006\u0000\u0000\u015a\u015d\u0005\u0001"+ | |
| "\u0000\u0000\u015b\u015d\u0005\u0004\u0000\u0000\u015c\u0158\u0001\u0000"+ | |
| "\u0000\u0000\u015c\u0159\u0001\u0000\u0000\u0000\u015c\u015a\u0001\u0000"+ | |
| "\u0000\u0000\u015c\u015b\u0001\u0000\u0000\u0000\u015d\u0160\u0001\u0000"+ | |
| "\u0000\u0000\u015e\u015c\u0001\u0000\u0000\u0000\u015e\u015f\u0001\u0000"+ | |
| "\u0000\u0000\u015f\u0161\u0001\u0000\u0000\u0000\u0160\u015e\u0001\u0000"+ | |
| "\u0000\u0000\u0161\u0162\u00057\u0000\u0000\u0162\r\u0001\u0000\u0000"+ | |
| "\u0000\u0163\u0164\u0005\u0005\u0000\u0000\u0164\u0165\u00059\u0000\u0000"+ | |
| "\u0165\u0169\u0005;\u0000\u0000\u0166\u0168\u0007\u0000\u0000\u0000\u0167"+ | |
| "\u0166\u0001\u0000\u0000\u0000\u0168\u016b\u0001\u0000\u0000\u0000\u0169"+ | |
| "\u0167\u0001\u0000\u0000\u0000\u0169\u016a\u0001\u0000\u0000\u0000\u016a"+ | |
| "\u016c\u0001\u0000\u0000\u0000\u016b\u0169\u0001\u0000\u0000\u0000\u016c"+ | |
| "\u016d\u00057\u0000\u0000\u016d\u000f\u0001\u0000\u0000\u0000\u016e\u019f"+ | |
| "\u0003\f\u0006\u0000\u016f\u019e\u0003\n\u0005\u0000\u0170\u019e\u0003"+ | |
| "f3\u0000\u0171\u019e\u0003\u0016\u000b\u0000\u0172\u019e\u0003\u001c\u000e"+ | |
| "\u0000\u0173\u019e\u0003\"\u0011\u0000\u0174\u019e\u0003(\u0014\u0000"+ | |
| "\u0175\u019e\u0003.\u0017\u0000\u0176\u019e\u00034\u001a\u0000\u0177\u019e"+ | |
| "\u0003:\u001d\u0000\u0178\u019e\u0003@ \u0000\u0179\u019e\u0003F#\u0000"+ | |
| "\u017a\u019e\u0003L&\u0000\u017b\u019e\u0003R)\u0000\u017c\u019e\u0003"+ | |
| "X,\u0000\u017d\u019e\u0003d2\u0000\u017e\u019e\u0003^/\u0000\u017f\u019e"+ | |
| "\u0003\u00a4R\u0000\u0180\u019e\u0003\u00aaU\u0000\u0181\u019e\u0003\u00b0"+ | |
| "X\u0000\u0182\u019e\u0003\u00b6[\u0000\u0183\u019e\u0003\u00bc^\u0000"+ | |
| "\u0184\u019e\u0003\u0012\t\u0000\u0185\u019e\u0003\u0018\f\u0000\u0186"+ | |
| "\u019e\u0003\u001e\u000f\u0000\u0187\u019e\u0003$\u0012\u0000\u0188\u019e"+ | |
| "\u0003*\u0015\u0000\u0189\u019e\u00030\u0018\u0000\u018a\u019e\u00036"+ | |
| "\u001b\u0000\u018b\u019e\u0003<\u001e\u0000\u018c\u019e\u0003B!\u0000"+ | |
| "\u018d\u019e\u0003H$\u0000\u018e\u019e\u0003N\'\u0000\u018f\u019e\u0003"+ | |
| "T*\u0000\u0190\u019e\u0003`0\u0000\u0191\u019e\u0003Z-\u0000\u0192\u019e"+ | |
| "\u0003\u00a0P\u0000\u0193\u019e\u0003\u00a6S\u0000\u0194\u019e\u0003\u00ac"+ | |
| "V\u0000\u0195\u019e\u0003\u00b2Y\u0000\u0196\u019e\u0003\u00b8\\\u0000"+ | |
| "\u0197\u0198\u0004\b\u0003\u0000\u0198\u019e\u0005\u0001\u0000\u0000\u0199"+ | |
| "\u019e\u0003\u0092I\u0000\u019a\u019e\u0005\u0006\u0000\u0000\u019b\u019e"+ | |
| "\u0003\u0094J\u0000\u019c\u019e\u0003\u0090H\u0000\u019d\u016f\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u0170\u0001\u0000\u0000\u0000\u019d\u0171\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u0172\u0001\u0000\u0000\u0000\u019d\u0173\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u0174\u0001\u0000\u0000\u0000\u019d\u0175\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u0176\u0001\u0000\u0000\u0000\u019d\u0177\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u0178\u0001\u0000\u0000\u0000\u019d\u0179\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u017a\u0001\u0000\u0000\u0000\u019d\u017b\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u017c\u0001\u0000\u0000\u0000\u019d\u017d\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u017e\u0001\u0000\u0000\u0000\u019d\u017f\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u0180\u0001\u0000\u0000\u0000\u019d\u0181\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u0182\u0001\u0000\u0000\u0000\u019d\u0183\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u0184\u0001\u0000\u0000\u0000\u019d\u0185\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u0186\u0001\u0000\u0000\u0000\u019d\u0187\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u0188\u0001\u0000\u0000\u0000\u019d\u0189\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u018a\u0001\u0000\u0000\u0000\u019d\u018b\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u018c\u0001\u0000\u0000\u0000\u019d\u018d\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u018e\u0001\u0000\u0000\u0000\u019d\u018f\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u0190\u0001\u0000\u0000\u0000\u019d\u0191\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u0192\u0001\u0000\u0000\u0000\u019d\u0193\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u0194\u0001\u0000\u0000\u0000\u019d\u0195\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u0196\u0001\u0000\u0000\u0000\u019d\u0197\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u0199\u0001\u0000\u0000\u0000\u019d\u019a\u0001\u0000"+ | |
| "\u0000\u0000\u019d\u019b\u0001\u0000\u0000\u0000\u019d\u019c\u0001\u0000"+ | |
| "\u0000\u0000\u019e\u01a1\u0001\u0000\u0000\u0000\u019f\u019d\u0001\u0000"+ | |
| "\u0000\u0000\u019f\u01a0\u0001\u0000\u0000\u0000\u01a0\u01a2\u0001\u0000"+ | |
| "\u0000\u0000\u01a1\u019f\u0001\u0000\u0000\u0000\u01a2\u01a3\u0003\u000e"+ | |
| "\u0007\u0000\u01a3\u0011\u0001\u0000\u0000\u0000\u01a4\u01a5\u0005\u0005"+ | |
| "\u0000\u0000\u01a5\u01ac\u0005<\u0000\u0000\u01a6\u01ab\u0003\b\u0004"+ | |
| "\u0000\u01a7\u01ab\u0005\u0006\u0000\u0000\u01a8\u01ab\u0005\u0001\u0000"+ | |
| "\u0000\u01a9\u01ab\u0005\u0004\u0000\u0000\u01aa\u01a6\u0001\u0000\u0000"+ | |
| "\u0000\u01aa\u01a7\u0001\u0000\u0000\u0000\u01aa\u01a8\u0001\u0000\u0000"+ | |
| "\u0000\u01aa\u01a9\u0001\u0000\u0000\u0000\u01ab\u01ae\u0001\u0000\u0000"+ | |
| "\u0000\u01ac\u01aa\u0001\u0000\u0000\u0000\u01ac\u01ad\u0001\u0000\u0000"+ | |
| "\u0000\u01ad\u01af\u0001\u0000\u0000\u0000\u01ae\u01ac\u0001\u0000\u0000"+ | |
| "\u0000\u01af\u01b0\u00057\u0000\u0000\u01b0\u0013\u0001\u0000\u0000\u0000"+ | |
| "\u01b1\u01b2\u0005\u0005\u0000\u0000\u01b2\u01b3\u00059\u0000\u0000\u01b3"+ | |
| "\u01b7\u0005<\u0000\u0000\u01b4\u01b6\u0007\u0000\u0000\u0000\u01b5\u01b4"+ | |
| "\u0001\u0000\u0000\u0000\u01b6\u01b9\u0001\u0000\u0000\u0000\u01b7\u01b5"+ | |
| "\u0001\u0000\u0000\u0000\u01b7\u01b8\u0001\u0000\u0000\u0000\u01b8\u01ba"+ | |
| "\u0001\u0000\u0000\u0000\u01b9\u01b7\u0001\u0000\u0000\u0000\u01ba\u01bb"+ | |
| "\u00057\u0000\u0000\u01bb\u0015\u0001\u0000\u0000\u0000\u01bc\u01ed\u0003"+ | |
| "\u0012\t\u0000\u01bd\u01ec\u0003\n\u0005\u0000\u01be\u01ec\u0003f3\u0000"+ | |
| "\u01bf\u01ec\u0003\u0010\b\u0000\u01c0\u01ec\u0003\u001c\u000e\u0000\u01c1"+ | |
| "\u01ec\u0003\"\u0011\u0000\u01c2\u01ec\u0003(\u0014\u0000\u01c3\u01ec"+ | |
| "\u0003.\u0017\u0000\u01c4\u01ec\u00034\u001a\u0000\u01c5\u01ec\u0003:"+ | |
| "\u001d\u0000\u01c6\u01ec\u0003@ \u0000\u01c7\u01ec\u0003F#\u0000\u01c8"+ | |
| "\u01ec\u0003L&\u0000\u01c9\u01ec\u0003R)\u0000\u01ca\u01ec\u0003X,\u0000"+ | |
| "\u01cb\u01ec\u0003d2\u0000\u01cc\u01ec\u0003^/\u0000\u01cd\u01ec\u0003"+ | |
| "\u00a4R\u0000\u01ce\u01ec\u0003\u00aaU\u0000\u01cf\u01ec\u0003\u00b0X"+ | |
| "\u0000\u01d0\u01ec\u0003\u00b6[\u0000\u01d1\u01ec\u0003\u00bc^\u0000\u01d2"+ | |
| "\u01ec\u0003\f\u0006\u0000\u01d3\u01ec\u0003\u0018\f\u0000\u01d4\u01ec"+ | |
| "\u0003\u001e\u000f\u0000\u01d5\u01ec\u0003$\u0012\u0000\u01d6\u01ec\u0003"+ | |
| "*\u0015\u0000\u01d7\u01ec\u00030\u0018\u0000\u01d8\u01ec\u00036\u001b"+ | |
| "\u0000\u01d9\u01ec\u0003<\u001e\u0000\u01da\u01ec\u0003B!\u0000\u01db"+ | |
| "\u01ec\u0003H$\u0000\u01dc\u01ec\u0003N\'\u0000\u01dd\u01ec\u0003T*\u0000"+ | |
| "\u01de\u01ec\u0003`0\u0000\u01df\u01ec\u0003Z-\u0000\u01e0\u01ec\u0003"+ | |
| "\u00a0P\u0000\u01e1\u01ec\u0003\u00a6S\u0000\u01e2\u01ec\u0003\u00acV"+ | |
| "\u0000\u01e3\u01ec\u0003\u00b2Y\u0000\u01e4\u01ec\u0003\u00b8\\\u0000"+ | |
| "\u01e5\u01e6\u0004\u000b\u0004\u0000\u01e6\u01ec\u0005\u0001\u0000\u0000"+ | |
| "\u01e7\u01ec\u0003\u0092I\u0000\u01e8\u01ec\u0005\u0006\u0000\u0000\u01e9"+ | |
| "\u01ec\u0003\u0094J\u0000\u01ea\u01ec\u0003\u0090H\u0000\u01eb\u01bd\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01be\u0001\u0000\u0000\u0000\u01eb\u01bf\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01c0\u0001\u0000\u0000\u0000\u01eb\u01c1\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01c2\u0001\u0000\u0000\u0000\u01eb\u01c3\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01c4\u0001\u0000\u0000\u0000\u01eb\u01c5\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01c6\u0001\u0000\u0000\u0000\u01eb\u01c7\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01c8\u0001\u0000\u0000\u0000\u01eb\u01c9\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01ca\u0001\u0000\u0000\u0000\u01eb\u01cb\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01cc\u0001\u0000\u0000\u0000\u01eb\u01cd\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01ce\u0001\u0000\u0000\u0000\u01eb\u01cf\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01d0\u0001\u0000\u0000\u0000\u01eb\u01d1\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01d2\u0001\u0000\u0000\u0000\u01eb\u01d3\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01d4\u0001\u0000\u0000\u0000\u01eb\u01d5\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01d6\u0001\u0000\u0000\u0000\u01eb\u01d7\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01d8\u0001\u0000\u0000\u0000\u01eb\u01d9\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01da\u0001\u0000\u0000\u0000\u01eb\u01db\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01dc\u0001\u0000\u0000\u0000\u01eb\u01dd\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01de\u0001\u0000\u0000\u0000\u01eb\u01df\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01e0\u0001\u0000\u0000\u0000\u01eb\u01e1\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01e2\u0001\u0000\u0000\u0000\u01eb\u01e3\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01e4\u0001\u0000\u0000\u0000\u01eb\u01e5\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01e7\u0001\u0000\u0000\u0000\u01eb\u01e8\u0001"+ | |
| "\u0000\u0000\u0000\u01eb\u01e9\u0001\u0000\u0000\u0000\u01eb\u01ea\u0001"+ | |
| "\u0000\u0000\u0000\u01ec\u01ef\u0001\u0000\u0000\u0000\u01ed\u01eb\u0001"+ | |
| "\u0000\u0000\u0000\u01ed\u01ee\u0001\u0000\u0000\u0000\u01ee\u01f0\u0001"+ | |
| "\u0000\u0000\u0000\u01ef\u01ed\u0001\u0000\u0000\u0000\u01f0\u01f1\u0003"+ | |
| "\u0014\n\u0000\u01f1\u0017\u0001\u0000\u0000\u0000\u01f2\u01f3\u0005\u0005"+ | |
| "\u0000\u0000\u01f3\u01fa\u0005=\u0000\u0000\u01f4\u01f9\u0003\b\u0004"+ | |
| "\u0000\u01f5\u01f9\u0005\u0006\u0000\u0000\u01f6\u01f9\u0005\u0001\u0000"+ | |
| "\u0000\u01f7\u01f9\u0005\u0004\u0000\u0000\u01f8\u01f4\u0001\u0000\u0000"+ | |
| "\u0000\u01f8\u01f5\u0001\u0000\u0000\u0000\u01f8\u01f6\u0001\u0000\u0000"+ | |
| "\u0000\u01f8\u01f7\u0001\u0000\u0000\u0000\u01f9\u01fc\u0001\u0000\u0000"+ | |
| "\u0000\u01fa\u01f8\u0001\u0000\u0000\u0000\u01fa\u01fb\u0001\u0000\u0000"+ | |
| "\u0000\u01fb\u01fd\u0001\u0000\u0000\u0000\u01fc\u01fa\u0001\u0000\u0000"+ | |
| "\u0000\u01fd\u01fe\u00057\u0000\u0000\u01fe\u0019\u0001\u0000\u0000\u0000"+ | |
| "\u01ff\u0200\u0005\u0005\u0000\u0000\u0200\u0201\u00059\u0000\u0000\u0201"+ | |
| "\u0205\u0005=\u0000\u0000\u0202\u0204\u0007\u0000\u0000\u0000\u0203\u0202"+ | |
| "\u0001\u0000\u0000\u0000\u0204\u0207\u0001\u0000\u0000\u0000\u0205\u0203"+ | |
| "\u0001\u0000\u0000\u0000\u0205\u0206\u0001\u0000\u0000\u0000\u0206\u0208"+ | |
| "\u0001\u0000\u0000\u0000\u0207\u0205\u0001\u0000\u0000\u0000\u0208\u0209"+ | |
| "\u00057\u0000\u0000\u0209\u001b\u0001\u0000\u0000\u0000\u020a\u023b\u0003"+ | |
| "\u0018\f\u0000\u020b\u023a\u0003\n\u0005\u0000\u020c\u023a\u0003f3\u0000"+ | |
| "\u020d\u023a\u0003\u0010\b\u0000\u020e\u023a\u0003\u0016\u000b\u0000\u020f"+ | |
| "\u023a\u0003\"\u0011\u0000\u0210\u023a\u0003(\u0014\u0000\u0211\u023a"+ | |
| "\u0003.\u0017\u0000\u0212\u023a\u00034\u001a\u0000\u0213\u023a\u0003:"+ | |
| "\u001d\u0000\u0214\u023a\u0003@ \u0000\u0215\u023a\u0003F#\u0000\u0216"+ | |
| "\u023a\u0003L&\u0000\u0217\u023a\u0003R)\u0000\u0218\u023a\u0003X,\u0000"+ | |
| "\u0219\u023a\u0003d2\u0000\u021a\u023a\u0003^/\u0000\u021b\u023a\u0003"+ | |
| "\u00a4R\u0000\u021c\u023a\u0003\u00aaU\u0000\u021d\u023a\u0003\u00b0X"+ | |
| "\u0000\u021e\u023a\u0003\u00b6[\u0000\u021f\u023a\u0003\u00bc^\u0000\u0220"+ | |
| "\u023a\u0003\f\u0006\u0000\u0221\u023a\u0003\u0012\t\u0000\u0222\u023a"+ | |
| "\u0003\u001e\u000f\u0000\u0223\u023a\u0003$\u0012\u0000\u0224\u023a\u0003"+ | |
| "*\u0015\u0000\u0225\u023a\u00030\u0018\u0000\u0226\u023a\u00036\u001b"+ | |
| "\u0000\u0227\u023a\u0003<\u001e\u0000\u0228\u023a\u0003B!\u0000\u0229"+ | |
| "\u023a\u0003H$\u0000\u022a\u023a\u0003N\'\u0000\u022b\u023a\u0003T*\u0000"+ | |
| "\u022c\u023a\u0003`0\u0000\u022d\u023a\u0003Z-\u0000\u022e\u023a\u0003"+ | |
| "\u00a0P\u0000\u022f\u023a\u0003\u00a6S\u0000\u0230\u023a\u0003\u00acV"+ | |
| "\u0000\u0231\u023a\u0003\u00b2Y\u0000\u0232\u023a\u0003\u00b8\\\u0000"+ | |
| "\u0233\u0234\u0004\u000e\u0005\u0000\u0234\u023a\u0005\u0001\u0000\u0000"+ | |
| "\u0235\u023a\u0003\u0092I\u0000\u0236\u023a\u0005\u0006\u0000\u0000\u0237"+ | |
| "\u023a\u0003\u0094J\u0000\u0238\u023a\u0003\u0090H\u0000\u0239\u020b\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u020c\u0001\u0000\u0000\u0000\u0239\u020d\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u020e\u0001\u0000\u0000\u0000\u0239\u020f\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u0210\u0001\u0000\u0000\u0000\u0239\u0211\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u0212\u0001\u0000\u0000\u0000\u0239\u0213\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u0214\u0001\u0000\u0000\u0000\u0239\u0215\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u0216\u0001\u0000\u0000\u0000\u0239\u0217\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u0218\u0001\u0000\u0000\u0000\u0239\u0219\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u021a\u0001\u0000\u0000\u0000\u0239\u021b\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u021c\u0001\u0000\u0000\u0000\u0239\u021d\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u021e\u0001\u0000\u0000\u0000\u0239\u021f\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u0220\u0001\u0000\u0000\u0000\u0239\u0221\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u0222\u0001\u0000\u0000\u0000\u0239\u0223\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u0224\u0001\u0000\u0000\u0000\u0239\u0225\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u0226\u0001\u0000\u0000\u0000\u0239\u0227\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u0228\u0001\u0000\u0000\u0000\u0239\u0229\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u022a\u0001\u0000\u0000\u0000\u0239\u022b\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u022c\u0001\u0000\u0000\u0000\u0239\u022d\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u022e\u0001\u0000\u0000\u0000\u0239\u022f\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u0230\u0001\u0000\u0000\u0000\u0239\u0231\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u0232\u0001\u0000\u0000\u0000\u0239\u0233\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u0235\u0001\u0000\u0000\u0000\u0239\u0236\u0001"+ | |
| "\u0000\u0000\u0000\u0239\u0237\u0001\u0000\u0000\u0000\u0239\u0238\u0001"+ | |
| "\u0000\u0000\u0000\u023a\u023d\u0001\u0000\u0000\u0000\u023b\u0239\u0001"+ | |
| "\u0000\u0000\u0000\u023b\u023c\u0001\u0000\u0000\u0000\u023c\u023e\u0001"+ | |
| "\u0000\u0000\u0000\u023d\u023b\u0001\u0000\u0000\u0000\u023e\u023f\u0003"+ | |
| "\u001a\r\u0000\u023f\u001d\u0001\u0000\u0000\u0000\u0240\u0241\u0005\u0005"+ | |
| "\u0000\u0000\u0241\u0248\u0005>\u0000\u0000\u0242\u0247\u0003\b\u0004"+ | |
| "\u0000\u0243\u0247\u0005\u0006\u0000\u0000\u0244\u0247\u0005\u0001\u0000"+ | |
| "\u0000\u0245\u0247\u0005\u0004\u0000\u0000\u0246\u0242\u0001\u0000\u0000"+ | |
| "\u0000\u0246\u0243\u0001\u0000\u0000\u0000\u0246\u0244\u0001\u0000\u0000"+ | |
| "\u0000\u0246\u0245\u0001\u0000\u0000\u0000\u0247\u024a\u0001\u0000\u0000"+ | |
| "\u0000\u0248\u0246\u0001\u0000\u0000\u0000\u0248\u0249\u0001\u0000\u0000"+ | |
| "\u0000\u0249\u024b\u0001\u0000\u0000\u0000\u024a\u0248\u0001\u0000\u0000"+ | |
| "\u0000\u024b\u024c\u00057\u0000\u0000\u024c\u001f\u0001\u0000\u0000\u0000"+ | |
| "\u024d\u024e\u0005\u0005\u0000\u0000\u024e\u024f\u00059\u0000\u0000\u024f"+ | |
| "\u0253\u0005>\u0000\u0000\u0250\u0252\u0007\u0000\u0000\u0000\u0251\u0250"+ | |
| "\u0001\u0000\u0000\u0000\u0252\u0255\u0001\u0000\u0000\u0000\u0253\u0251"+ | |
| "\u0001\u0000\u0000\u0000\u0253\u0254\u0001\u0000\u0000\u0000\u0254\u0256"+ | |
| "\u0001\u0000\u0000\u0000\u0255\u0253\u0001\u0000\u0000\u0000\u0256\u0257"+ | |
| "\u00057\u0000\u0000\u0257!\u0001\u0000\u0000\u0000\u0258\u0289\u0003\u001e"+ | |
| "\u000f\u0000\u0259\u0288\u0003\n\u0005\u0000\u025a\u0288\u0003f3\u0000"+ | |
| "\u025b\u0288\u0003\u0010\b\u0000\u025c\u0288\u0003\u0016\u000b\u0000\u025d"+ | |
| "\u0288\u0003\u001c\u000e\u0000\u025e\u0288\u0003(\u0014\u0000\u025f\u0288"+ | |
| "\u0003.\u0017\u0000\u0260\u0288\u00034\u001a\u0000\u0261\u0288\u0003:"+ | |
| "\u001d\u0000\u0262\u0288\u0003@ \u0000\u0263\u0288\u0003F#\u0000\u0264"+ | |
| "\u0288\u0003L&\u0000\u0265\u0288\u0003R)\u0000\u0266\u0288\u0003X,\u0000"+ | |
| "\u0267\u0288\u0003d2\u0000\u0268\u0288\u0003^/\u0000\u0269\u0288\u0003"+ | |
| "\u00a4R\u0000\u026a\u0288\u0003\u00aaU\u0000\u026b\u0288\u0003\u00b0X"+ | |
| "\u0000\u026c\u0288\u0003\u00b6[\u0000\u026d\u0288\u0003\u00bc^\u0000\u026e"+ | |
| "\u0288\u0003\f\u0006\u0000\u026f\u0288\u0003\u0012\t\u0000\u0270\u0288"+ | |
| "\u0003\u001e\u000f\u0000\u0271\u0288\u0003$\u0012\u0000\u0272\u0288\u0003"+ | |
| "*\u0015\u0000\u0273\u0288\u00030\u0018\u0000\u0274\u0288\u00036\u001b"+ | |
| "\u0000\u0275\u0288\u0003<\u001e\u0000\u0276\u0288\u0003B!\u0000\u0277"+ | |
| "\u0288\u0003H$\u0000\u0278\u0288\u0003N\'\u0000\u0279\u0288\u0003T*\u0000"+ | |
| "\u027a\u0288\u0003`0\u0000\u027b\u0288\u0003Z-\u0000\u027c\u0288\u0003"+ | |
| "\u00a0P\u0000\u027d\u0288\u0003\u00a6S\u0000\u027e\u0288\u0003\u00acV"+ | |
| "\u0000\u027f\u0288\u0003\u00b2Y\u0000\u0280\u0288\u0003\u00b8\\\u0000"+ | |
| "\u0281\u0282\u0004\u0011\u0006\u0000\u0282\u0288\u0005\u0001\u0000\u0000"+ | |
| "\u0283\u0288\u0003\u0092I\u0000\u0284\u0288\u0005\u0006\u0000\u0000\u0285"+ | |
| "\u0288\u0003\u0094J\u0000\u0286\u0288\u0003\u0090H\u0000\u0287\u0259\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u025a\u0001\u0000\u0000\u0000\u0287\u025b\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u025c\u0001\u0000\u0000\u0000\u0287\u025d\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u025e\u0001\u0000\u0000\u0000\u0287\u025f\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u0260\u0001\u0000\u0000\u0000\u0287\u0261\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u0262\u0001\u0000\u0000\u0000\u0287\u0263\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u0264\u0001\u0000\u0000\u0000\u0287\u0265\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u0266\u0001\u0000\u0000\u0000\u0287\u0267\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u0268\u0001\u0000\u0000\u0000\u0287\u0269\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u026a\u0001\u0000\u0000\u0000\u0287\u026b\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u026c\u0001\u0000\u0000\u0000\u0287\u026d\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u026e\u0001\u0000\u0000\u0000\u0287\u026f\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u0270\u0001\u0000\u0000\u0000\u0287\u0271\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u0272\u0001\u0000\u0000\u0000\u0287\u0273\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u0274\u0001\u0000\u0000\u0000\u0287\u0275\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u0276\u0001\u0000\u0000\u0000\u0287\u0277\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u0278\u0001\u0000\u0000\u0000\u0287\u0279\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u027a\u0001\u0000\u0000\u0000\u0287\u027b\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u027c\u0001\u0000\u0000\u0000\u0287\u027d\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u027e\u0001\u0000\u0000\u0000\u0287\u027f\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u0280\u0001\u0000\u0000\u0000\u0287\u0281\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u0283\u0001\u0000\u0000\u0000\u0287\u0284\u0001"+ | |
| "\u0000\u0000\u0000\u0287\u0285\u0001\u0000\u0000\u0000\u0287\u0286\u0001"+ | |
| "\u0000\u0000\u0000\u0288\u028b\u0001\u0000\u0000\u0000\u0289\u0287\u0001"+ | |
| "\u0000\u0000\u0000\u0289\u028a\u0001\u0000\u0000\u0000\u028a\u028c\u0001"+ | |
| "\u0000\u0000\u0000\u028b\u0289\u0001\u0000\u0000\u0000\u028c\u028d\u0003"+ | |
| " \u0010\u0000\u028d#\u0001\u0000\u0000\u0000\u028e\u028f\u0005\u0005\u0000"+ | |
| "\u0000\u028f\u0296\u0005?\u0000\u0000\u0290\u0295\u0003\b\u0004\u0000"+ | |
| "\u0291\u0295\u0005\u0006\u0000\u0000\u0292\u0295\u0005\u0001\u0000\u0000"+ | |
| "\u0293\u0295\u0005\u0004\u0000\u0000\u0294\u0290\u0001\u0000\u0000\u0000"+ | |
| "\u0294\u0291\u0001\u0000\u0000\u0000\u0294\u0292\u0001\u0000\u0000\u0000"+ | |
| "\u0294\u0293\u0001\u0000\u0000\u0000\u0295\u0298\u0001\u0000\u0000\u0000"+ | |
| "\u0296\u0294\u0001\u0000\u0000\u0000\u0296\u0297\u0001\u0000\u0000\u0000"+ | |
| "\u0297\u0299\u0001\u0000\u0000\u0000\u0298\u0296\u0001\u0000\u0000\u0000"+ | |
| "\u0299\u029a\u00057\u0000\u0000\u029a%\u0001\u0000\u0000\u0000\u029b\u029c"+ | |
| "\u0005\u0005\u0000\u0000\u029c\u029d\u00059\u0000\u0000\u029d\u02a1\u0005"+ | |
| "?\u0000\u0000\u029e\u02a0\u0007\u0000\u0000\u0000\u029f\u029e\u0001\u0000"+ | |
| "\u0000\u0000\u02a0\u02a3\u0001\u0000\u0000\u0000\u02a1\u029f\u0001\u0000"+ | |
| "\u0000\u0000\u02a1\u02a2\u0001\u0000\u0000\u0000\u02a2\u02a4\u0001\u0000"+ | |
| "\u0000\u0000\u02a3\u02a1\u0001\u0000\u0000\u0000\u02a4\u02a5\u00057\u0000"+ | |
| "\u0000\u02a5\'\u0001\u0000\u0000\u0000\u02a6\u02d7\u0003$\u0012\u0000"+ | |
| "\u02a7\u02d6\u0003\n\u0005\u0000\u02a8\u02d6\u0003f3\u0000\u02a9\u02d6"+ | |
| "\u0003\u0010\b\u0000\u02aa\u02d6\u0003\u0016\u000b\u0000\u02ab\u02d6\u0003"+ | |
| "\u001c\u000e\u0000\u02ac\u02d6\u0003\"\u0011\u0000\u02ad\u02d6\u0003."+ | |
| "\u0017\u0000\u02ae\u02d6\u00034\u001a\u0000\u02af\u02d6\u0003:\u001d\u0000"+ | |
| "\u02b0\u02d6\u0003@ \u0000\u02b1\u02d6\u0003F#\u0000\u02b2\u02d6\u0003"+ | |
| "L&\u0000\u02b3\u02d6\u0003R)\u0000\u02b4\u02d6\u0003X,\u0000\u02b5\u02d6"+ | |
| "\u0003d2\u0000\u02b6\u02d6\u0003^/\u0000\u02b7\u02d6\u0003\u00a4R\u0000"+ | |
| "\u02b8\u02d6\u0003\u00aaU\u0000\u02b9\u02d6\u0003\u00b0X\u0000\u02ba\u02d6"+ | |
| "\u0003\u00b6[\u0000\u02bb\u02d6\u0003\u00bc^\u0000\u02bc\u02d6\u0003\f"+ | |
| "\u0006\u0000\u02bd\u02d6\u0003\u0012\t\u0000\u02be\u02d6\u0003\u0018\f"+ | |
| "\u0000\u02bf\u02d6\u0003\u001e\u000f\u0000\u02c0\u02d6\u0003*\u0015\u0000"+ | |
| "\u02c1\u02d6\u00030\u0018\u0000\u02c2\u02d6\u00036\u001b\u0000\u02c3\u02d6"+ | |
| "\u0003<\u001e\u0000\u02c4\u02d6\u0003B!\u0000\u02c5\u02d6\u0003H$\u0000"+ | |
| "\u02c6\u02d6\u0003N\'\u0000\u02c7\u02d6\u0003T*\u0000\u02c8\u02d6\u0003"+ | |
| "`0\u0000\u02c9\u02d6\u0003Z-\u0000\u02ca\u02d6\u0003\u00a0P\u0000\u02cb"+ | |
| "\u02d6\u0003\u00a6S\u0000\u02cc\u02d6\u0003\u00acV\u0000\u02cd\u02d6\u0003"+ | |
| "\u00b2Y\u0000\u02ce\u02d6\u0003\u00b8\\\u0000\u02cf\u02d0\u0004\u0014"+ | |
| "\u0007\u0000\u02d0\u02d6\u0005\u0001\u0000\u0000\u02d1\u02d6\u0003\u0092"+ | |
| "I\u0000\u02d2\u02d6\u0005\u0006\u0000\u0000\u02d3\u02d6\u0003\u0094J\u0000"+ | |
| "\u02d4\u02d6\u0003\u0090H\u0000\u02d5\u02a7\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02a8\u0001\u0000\u0000\u0000\u02d5\u02a9\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02aa\u0001\u0000\u0000\u0000\u02d5\u02ab\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02ac\u0001\u0000\u0000\u0000\u02d5\u02ad\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02ae\u0001\u0000\u0000\u0000\u02d5\u02af\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02b0\u0001\u0000\u0000\u0000\u02d5\u02b1\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02b2\u0001\u0000\u0000\u0000\u02d5\u02b3\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02b4\u0001\u0000\u0000\u0000\u02d5\u02b5\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02b6\u0001\u0000\u0000\u0000\u02d5\u02b7\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02b8\u0001\u0000\u0000\u0000\u02d5\u02b9\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02ba\u0001\u0000\u0000\u0000\u02d5\u02bb\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02bc\u0001\u0000\u0000\u0000\u02d5\u02bd\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02be\u0001\u0000\u0000\u0000\u02d5\u02bf\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02c0\u0001\u0000\u0000\u0000\u02d5\u02c1\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02c2\u0001\u0000\u0000\u0000\u02d5\u02c3\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02c4\u0001\u0000\u0000\u0000\u02d5\u02c5\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02c6\u0001\u0000\u0000\u0000\u02d5\u02c7\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02c8\u0001\u0000\u0000\u0000\u02d5\u02c9\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02ca\u0001\u0000\u0000\u0000\u02d5\u02cb\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02cc\u0001\u0000\u0000\u0000\u02d5\u02cd\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02ce\u0001\u0000\u0000\u0000\u02d5\u02cf\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02d1\u0001\u0000\u0000\u0000\u02d5\u02d2\u0001\u0000\u0000\u0000\u02d5"+ | |
| "\u02d3\u0001\u0000\u0000\u0000\u02d5\u02d4\u0001\u0000\u0000\u0000\u02d6"+ | |
| "\u02d9\u0001\u0000\u0000\u0000\u02d7\u02d5\u0001\u0000\u0000\u0000\u02d7"+ | |
| "\u02d8\u0001\u0000\u0000\u0000\u02d8\u02da\u0001\u0000\u0000\u0000\u02d9"+ | |
| "\u02d7\u0001\u0000\u0000\u0000\u02da\u02db\u0003&\u0013\u0000\u02db)\u0001"+ | |
| "\u0000\u0000\u0000\u02dc\u02dd\u0005\u0005\u0000\u0000\u02dd\u02e4\u0005"+ | |
| "@\u0000\u0000\u02de\u02e3\u0003\b\u0004\u0000\u02df\u02e3\u0005\u0006"+ | |
| "\u0000\u0000\u02e0\u02e3\u0005\u0001\u0000\u0000\u02e1\u02e3\u0005\u0004"+ | |
| "\u0000\u0000\u02e2\u02de\u0001\u0000\u0000\u0000\u02e2\u02df\u0001\u0000"+ | |
| "\u0000\u0000\u02e2\u02e0\u0001\u0000\u0000\u0000\u02e2\u02e1\u0001\u0000"+ | |
| "\u0000\u0000\u02e3\u02e6\u0001\u0000\u0000\u0000\u02e4\u02e2\u0001\u0000"+ | |
| "\u0000\u0000\u02e4\u02e5\u0001\u0000\u0000\u0000\u02e5\u02e7\u0001\u0000"+ | |
| "\u0000\u0000\u02e6\u02e4\u0001\u0000\u0000\u0000\u02e7\u02e8\u00057\u0000"+ | |
| "\u0000\u02e8+\u0001\u0000\u0000\u0000\u02e9\u02ea\u0005\u0005\u0000\u0000"+ | |
| "\u02ea\u02eb\u00059\u0000\u0000\u02eb\u02ef\u0005@\u0000\u0000\u02ec\u02ee"+ | |
| "\u0007\u0000\u0000\u0000\u02ed\u02ec\u0001\u0000\u0000\u0000\u02ee\u02f1"+ | |
| "\u0001\u0000\u0000\u0000\u02ef\u02ed\u0001\u0000\u0000\u0000\u02ef\u02f0"+ | |
| "\u0001\u0000\u0000\u0000\u02f0\u02f2\u0001\u0000\u0000\u0000\u02f1\u02ef"+ | |
| "\u0001\u0000\u0000\u0000\u02f2\u02f3\u00057\u0000\u0000\u02f3-\u0001\u0000"+ | |
| "\u0000\u0000\u02f4\u0325\u0003*\u0015\u0000\u02f5\u0324\u0003\n\u0005"+ | |
| "\u0000\u02f6\u0324\u0003f3\u0000\u02f7\u0324\u0003\u0010\b\u0000\u02f8"+ | |
| "\u0324\u0003\u0016\u000b\u0000\u02f9\u0324\u0003\u001c\u000e\u0000\u02fa"+ | |
| "\u0324\u0003\"\u0011\u0000\u02fb\u0324\u0003(\u0014\u0000\u02fc\u0324"+ | |
| "\u00034\u001a\u0000\u02fd\u0324\u0003:\u001d\u0000\u02fe\u0324\u0003@"+ | |
| " \u0000\u02ff\u0324\u0003F#\u0000\u0300\u0324\u0003L&\u0000\u0301\u0324"+ | |
| "\u0003R)\u0000\u0302\u0324\u0003X,\u0000\u0303\u0324\u0003d2\u0000\u0304"+ | |
| "\u0324\u0003^/\u0000\u0305\u0324\u0003\u00a4R\u0000\u0306\u0324\u0003"+ | |
| "\u00aaU\u0000\u0307\u0324\u0003\u00b0X\u0000\u0308\u0324\u0003\u00b6["+ | |
| "\u0000\u0309\u0324\u0003\u00bc^\u0000\u030a\u0324\u0003\f\u0006\u0000"+ | |
| "\u030b\u0324\u0003\u0012\t\u0000\u030c\u0324\u0003\u0018\f\u0000\u030d"+ | |
| "\u0324\u0003\u001e\u000f\u0000\u030e\u0324\u0003$\u0012\u0000\u030f\u0324"+ | |
| "\u00030\u0018\u0000\u0310\u0324\u00036\u001b\u0000\u0311\u0324\u0003<"+ | |
| "\u001e\u0000\u0312\u0324\u0003B!\u0000\u0313\u0324\u0003H$\u0000\u0314"+ | |
| "\u0324\u0003N\'\u0000\u0315\u0324\u0003T*\u0000\u0316\u0324\u0003`0\u0000"+ | |
| "\u0317\u0324\u0003Z-\u0000\u0318\u0324\u0003\u00a0P\u0000\u0319\u0324"+ | |
| "\u0003\u00a6S\u0000\u031a\u0324\u0003\u00acV\u0000\u031b\u0324\u0003\u00b2"+ | |
| "Y\u0000\u031c\u0324\u0003\u00b8\\\u0000\u031d\u031e\u0004\u0017\b\u0000"+ | |
| "\u031e\u0324\u0005\u0001\u0000\u0000\u031f\u0324\u0003\u0092I\u0000\u0320"+ | |
| "\u0324\u0005\u0006\u0000\u0000\u0321\u0324\u0003\u0094J\u0000\u0322\u0324"+ | |
| "\u0003\u0090H\u0000\u0323\u02f5\u0001\u0000\u0000\u0000\u0323\u02f6\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u02f7\u0001\u0000\u0000\u0000\u0323\u02f8\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u02f9\u0001\u0000\u0000\u0000\u0323\u02fa\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u02fb\u0001\u0000\u0000\u0000\u0323\u02fc\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u02fd\u0001\u0000\u0000\u0000\u0323\u02fe\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u02ff\u0001\u0000\u0000\u0000\u0323\u0300\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u0301\u0001\u0000\u0000\u0000\u0323\u0302\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u0303\u0001\u0000\u0000\u0000\u0323\u0304\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u0305\u0001\u0000\u0000\u0000\u0323\u0306\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u0307\u0001\u0000\u0000\u0000\u0323\u0308\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u0309\u0001\u0000\u0000\u0000\u0323\u030a\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u030b\u0001\u0000\u0000\u0000\u0323\u030c\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u030d\u0001\u0000\u0000\u0000\u0323\u030e\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u030f\u0001\u0000\u0000\u0000\u0323\u0310\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u0311\u0001\u0000\u0000\u0000\u0323\u0312\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u0313\u0001\u0000\u0000\u0000\u0323\u0314\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u0315\u0001\u0000\u0000\u0000\u0323\u0316\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u0317\u0001\u0000\u0000\u0000\u0323\u0318\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u0319\u0001\u0000\u0000\u0000\u0323\u031a\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u031b\u0001\u0000\u0000\u0000\u0323\u031c\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u031d\u0001\u0000\u0000\u0000\u0323\u031f\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u0320\u0001\u0000\u0000\u0000\u0323\u0321\u0001"+ | |
| "\u0000\u0000\u0000\u0323\u0322\u0001\u0000\u0000\u0000\u0324\u0327\u0001"+ | |
| "\u0000\u0000\u0000\u0325\u0323\u0001\u0000\u0000\u0000\u0325\u0326\u0001"+ | |
| "\u0000\u0000\u0000\u0326\u0328\u0001\u0000\u0000\u0000\u0327\u0325\u0001"+ | |
| "\u0000\u0000\u0000\u0328\u0329\u0003,\u0016\u0000\u0329/\u0001\u0000\u0000"+ | |
| "\u0000\u032a\u032b\u0005\u0005\u0000\u0000\u032b\u0332\u0005A\u0000\u0000"+ | |
| "\u032c\u0331\u0003\b\u0004\u0000\u032d\u0331\u0005\u0006\u0000\u0000\u032e"+ | |
| "\u0331\u0005\u0001\u0000\u0000\u032f\u0331\u0005\u0004\u0000\u0000\u0330"+ | |
| "\u032c\u0001\u0000\u0000\u0000\u0330\u032d\u0001\u0000\u0000\u0000\u0330"+ | |
| "\u032e\u0001\u0000\u0000\u0000\u0330\u032f\u0001\u0000\u0000\u0000\u0331"+ | |
| "\u0334\u0001\u0000\u0000\u0000\u0332\u0330\u0001\u0000\u0000\u0000\u0332"+ | |
| "\u0333\u0001\u0000\u0000\u0000\u0333\u0335\u0001\u0000\u0000\u0000\u0334"+ | |
| "\u0332\u0001\u0000\u0000\u0000\u0335\u0336\u00057\u0000\u0000\u03361\u0001"+ | |
| "\u0000\u0000\u0000\u0337\u0338\u0005\u0005\u0000\u0000\u0338\u0339\u0005"+ | |
| "9\u0000\u0000\u0339\u033d\u0005A\u0000\u0000\u033a\u033c\u0007\u0000\u0000"+ | |
| "\u0000\u033b\u033a\u0001\u0000\u0000\u0000\u033c\u033f\u0001\u0000\u0000"+ | |
| "\u0000\u033d\u033b\u0001\u0000\u0000\u0000\u033d\u033e\u0001\u0000\u0000"+ | |
| "\u0000\u033e\u0340\u0001\u0000\u0000\u0000\u033f\u033d\u0001\u0000\u0000"+ | |
| "\u0000\u0340\u0341\u00057\u0000\u0000\u03413\u0001\u0000\u0000\u0000\u0342"+ | |
| "\u0373\u00030\u0018\u0000\u0343\u0372\u0003\n\u0005\u0000\u0344\u0372"+ | |
| "\u0003f3\u0000\u0345\u0372\u0003\u0010\b\u0000\u0346\u0372\u0003\u0016"+ | |
| "\u000b\u0000\u0347\u0372\u0003\u001c\u000e\u0000\u0348\u0372\u0003\"\u0011"+ | |
| "\u0000\u0349\u0372\u0003(\u0014\u0000\u034a\u0372\u0003.\u0017\u0000\u034b"+ | |
| "\u0372\u0003:\u001d\u0000\u034c\u0372\u0003@ \u0000\u034d\u0372\u0003"+ | |
| "F#\u0000\u034e\u0372\u0003L&\u0000\u034f\u0372\u0003R)\u0000\u0350\u0372"+ | |
| "\u0003X,\u0000\u0351\u0372\u0003d2\u0000\u0352\u0372\u0003^/\u0000\u0353"+ | |
| "\u0372\u0003\u00a4R\u0000\u0354\u0372\u0003\u00aaU\u0000\u0355\u0372\u0003"+ | |
| "\u00b0X\u0000\u0356\u0372\u0003\u00b6[\u0000\u0357\u0372\u0003\u00bc^"+ | |
| "\u0000\u0358\u0372\u0003\f\u0006\u0000\u0359\u0372\u0003\u0012\t\u0000"+ | |
| "\u035a\u0372\u0003\u0018\f\u0000\u035b\u0372\u0003\u001e\u000f\u0000\u035c"+ | |
| "\u0372\u0003$\u0012\u0000\u035d\u0372\u0003*\u0015\u0000\u035e\u0372\u0003"+ | |
| "6\u001b\u0000\u035f\u0372\u0003<\u001e\u0000\u0360\u0372\u0003B!\u0000"+ | |
| "\u0361\u0372\u0003H$\u0000\u0362\u0372\u0003N\'\u0000\u0363\u0372\u0003"+ | |
| "T*\u0000\u0364\u0372\u0003`0\u0000\u0365\u0372\u0003Z-\u0000\u0366\u0372"+ | |
| "\u0003\u00a0P\u0000\u0367\u0372\u0003\u00a6S\u0000\u0368\u0372\u0003\u00ac"+ | |
| "V\u0000\u0369\u0372\u0003\u00b2Y\u0000\u036a\u0372\u0003\u00b8\\\u0000"+ | |
| "\u036b\u036c\u0004\u001a\t\u0000\u036c\u0372\u0005\u0001\u0000\u0000\u036d"+ | |
| "\u0372\u0003\u0092I\u0000\u036e\u0372\u0005\u0006\u0000\u0000\u036f\u0372"+ | |
| "\u0003\u0094J\u0000\u0370\u0372\u0003\u0090H\u0000\u0371\u0343\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u0344\u0001\u0000\u0000\u0000\u0371\u0345\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u0346\u0001\u0000\u0000\u0000\u0371\u0347\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u0348\u0001\u0000\u0000\u0000\u0371\u0349\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u034a\u0001\u0000\u0000\u0000\u0371\u034b\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u034c\u0001\u0000\u0000\u0000\u0371\u034d\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u034e\u0001\u0000\u0000\u0000\u0371\u034f\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u0350\u0001\u0000\u0000\u0000\u0371\u0351\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u0352\u0001\u0000\u0000\u0000\u0371\u0353\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u0354\u0001\u0000\u0000\u0000\u0371\u0355\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u0356\u0001\u0000\u0000\u0000\u0371\u0357\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u0358\u0001\u0000\u0000\u0000\u0371\u0359\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u035a\u0001\u0000\u0000\u0000\u0371\u035b\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u035c\u0001\u0000\u0000\u0000\u0371\u035d\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u035e\u0001\u0000\u0000\u0000\u0371\u035f\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u0360\u0001\u0000\u0000\u0000\u0371\u0361\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u0362\u0001\u0000\u0000\u0000\u0371\u0363\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u0364\u0001\u0000\u0000\u0000\u0371\u0365\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u0366\u0001\u0000\u0000\u0000\u0371\u0367\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u0368\u0001\u0000\u0000\u0000\u0371\u0369\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u036a\u0001\u0000\u0000\u0000\u0371\u036b\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u036d\u0001\u0000\u0000\u0000\u0371\u036e\u0001\u0000"+ | |
| "\u0000\u0000\u0371\u036f\u0001\u0000\u0000\u0000\u0371\u0370\u0001\u0000"+ | |
| "\u0000\u0000\u0372\u0375\u0001\u0000\u0000\u0000\u0373\u0371\u0001\u0000"+ | |
| "\u0000\u0000\u0373\u0374\u0001\u0000\u0000\u0000\u0374\u0376\u0001\u0000"+ | |
| "\u0000\u0000\u0375\u0373\u0001\u0000\u0000\u0000\u0376\u0377\u00032\u0019"+ | |
| "\u0000\u03775\u0001\u0000\u0000\u0000\u0378\u0379\u0005\u0005\u0000\u0000"+ | |
| "\u0379\u0380\u0005B\u0000\u0000\u037a\u037f\u0003\b\u0004\u0000\u037b"+ | |
| "\u037f\u0005\u0006\u0000\u0000\u037c\u037f\u0005\u0001\u0000\u0000\u037d"+ | |
| "\u037f\u0005\u0004\u0000\u0000\u037e\u037a\u0001\u0000\u0000\u0000\u037e"+ | |
| "\u037b\u0001\u0000\u0000\u0000\u037e\u037c\u0001\u0000\u0000\u0000\u037e"+ | |
| "\u037d\u0001\u0000\u0000\u0000\u037f\u0382\u0001\u0000\u0000\u0000\u0380"+ | |
| "\u037e\u0001\u0000\u0000\u0000\u0380\u0381\u0001\u0000\u0000\u0000\u0381"+ | |
| "\u0383\u0001\u0000\u0000\u0000\u0382\u0380\u0001\u0000\u0000\u0000\u0383"+ | |
| "\u0384\u00057\u0000\u0000\u03847\u0001\u0000\u0000\u0000\u0385\u0386\u0005"+ | |
| "\u0005\u0000\u0000\u0386\u0387\u00059\u0000\u0000\u0387\u038b\u0005B\u0000"+ | |
| "\u0000\u0388\u038a\u0007\u0000\u0000\u0000\u0389\u0388\u0001\u0000\u0000"+ | |
| "\u0000\u038a\u038d\u0001\u0000\u0000\u0000\u038b\u0389\u0001\u0000\u0000"+ | |
| "\u0000\u038b\u038c\u0001\u0000\u0000\u0000\u038c\u038e\u0001\u0000\u0000"+ | |
| "\u0000\u038d\u038b\u0001\u0000\u0000\u0000\u038e\u038f\u00057\u0000\u0000"+ | |
| "\u038f9\u0001\u0000\u0000\u0000\u0390\u03c1\u00036\u001b\u0000\u0391\u03c0"+ | |
| "\u0003\n\u0005\u0000\u0392\u03c0\u0003f3\u0000\u0393\u03c0\u0003\u0010"+ | |
| "\b\u0000\u0394\u03c0\u0003\u0016\u000b\u0000\u0395\u03c0\u0003\u001c\u000e"+ | |
| "\u0000\u0396\u03c0\u0003\"\u0011\u0000\u0397\u03c0\u0003(\u0014\u0000"+ | |
| "\u0398\u03c0\u0003.\u0017\u0000\u0399\u03c0\u00034\u001a\u0000\u039a\u03c0"+ | |
| "\u0003@ \u0000\u039b\u03c0\u0003F#\u0000\u039c\u03c0\u0003L&\u0000\u039d"+ | |
| "\u03c0\u0003R)\u0000\u039e\u03c0\u0003X,\u0000\u039f\u03c0\u0003d2\u0000"+ | |
| "\u03a0\u03c0\u0003^/\u0000\u03a1\u03c0\u0003\u00a4R\u0000\u03a2\u03c0"+ | |
| "\u0003\u00aaU\u0000\u03a3\u03c0\u0003\u00b0X\u0000\u03a4\u03c0\u0003\u00b6"+ | |
| "[\u0000\u03a5\u03c0\u0003\u00bc^\u0000\u03a6\u03c0\u0003\f\u0006\u0000"+ | |
| "\u03a7\u03c0\u0003\u0012\t\u0000\u03a8\u03c0\u0003\u0018\f\u0000\u03a9"+ | |
| "\u03c0\u0003\u001e\u000f\u0000\u03aa\u03c0\u0003$\u0012\u0000\u03ab\u03c0"+ | |
| "\u0003*\u0015\u0000\u03ac\u03c0\u00030\u0018\u0000\u03ad\u03c0\u0003<"+ | |
| "\u001e\u0000\u03ae\u03c0\u0003B!\u0000\u03af\u03c0\u0003H$\u0000\u03b0"+ | |
| "\u03c0\u0003N\'\u0000\u03b1\u03c0\u0003T*\u0000\u03b2\u03c0\u0003`0\u0000"+ | |
| "\u03b3\u03c0\u0003Z-\u0000\u03b4\u03c0\u0003\u00a0P\u0000\u03b5\u03c0"+ | |
| "\u0003\u00a6S\u0000\u03b6\u03c0\u0003\u00acV\u0000\u03b7\u03c0\u0003\u00b2"+ | |
| "Y\u0000\u03b8\u03c0\u0003\u00b8\\\u0000\u03b9\u03ba\u0004\u001d\n\u0000"+ | |
| "\u03ba\u03c0\u0005\u0001\u0000\u0000\u03bb\u03c0\u0003\u0092I\u0000\u03bc"+ | |
| "\u03c0\u0005\u0006\u0000\u0000\u03bd\u03c0\u0003\u0094J\u0000\u03be\u03c0"+ | |
| "\u0003\u0090H\u0000\u03bf\u0391\u0001\u0000\u0000\u0000\u03bf\u0392\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u0393\u0001\u0000\u0000\u0000\u03bf\u0394\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u0395\u0001\u0000\u0000\u0000\u03bf\u0396\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u0397\u0001\u0000\u0000\u0000\u03bf\u0398\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u0399\u0001\u0000\u0000\u0000\u03bf\u039a\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u039b\u0001\u0000\u0000\u0000\u03bf\u039c\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u039d\u0001\u0000\u0000\u0000\u03bf\u039e\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u039f\u0001\u0000\u0000\u0000\u03bf\u03a0\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u03a1\u0001\u0000\u0000\u0000\u03bf\u03a2\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u03a3\u0001\u0000\u0000\u0000\u03bf\u03a4\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u03a5\u0001\u0000\u0000\u0000\u03bf\u03a6\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u03a7\u0001\u0000\u0000\u0000\u03bf\u03a8\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u03a9\u0001\u0000\u0000\u0000\u03bf\u03aa\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u03ab\u0001\u0000\u0000\u0000\u03bf\u03ac\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u03ad\u0001\u0000\u0000\u0000\u03bf\u03ae\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u03af\u0001\u0000\u0000\u0000\u03bf\u03b0\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u03b1\u0001\u0000\u0000\u0000\u03bf\u03b2\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u03b3\u0001\u0000\u0000\u0000\u03bf\u03b4\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u03b5\u0001\u0000\u0000\u0000\u03bf\u03b6\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u03b7\u0001\u0000\u0000\u0000\u03bf\u03b8\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u03b9\u0001\u0000\u0000\u0000\u03bf\u03bb\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u03bc\u0001\u0000\u0000\u0000\u03bf\u03bd\u0001"+ | |
| "\u0000\u0000\u0000\u03bf\u03be\u0001\u0000\u0000\u0000\u03c0\u03c3\u0001"+ | |
| "\u0000\u0000\u0000\u03c1\u03bf\u0001\u0000\u0000\u0000\u03c1\u03c2\u0001"+ | |
| "\u0000\u0000\u0000\u03c2\u03c4\u0001\u0000\u0000\u0000\u03c3\u03c1\u0001"+ | |
| "\u0000\u0000\u0000\u03c4\u03c5\u00038\u001c\u0000\u03c5;\u0001\u0000\u0000"+ | |
| "\u0000\u03c6\u03c7\u0005\u0005\u0000\u0000\u03c7\u03ce\u0005C\u0000\u0000"+ | |
| "\u03c8\u03cd\u0003\b\u0004\u0000\u03c9\u03cd\u0005\u0006\u0000\u0000\u03ca"+ | |
| "\u03cd\u0005\u0001\u0000\u0000\u03cb\u03cd\u0005\u0004\u0000\u0000\u03cc"+ | |
| "\u03c8\u0001\u0000\u0000\u0000\u03cc\u03c9\u0001\u0000\u0000\u0000\u03cc"+ | |
| "\u03ca\u0001\u0000\u0000\u0000\u03cc\u03cb\u0001\u0000\u0000\u0000\u03cd"+ | |
| "\u03d0\u0001\u0000\u0000\u0000\u03ce\u03cc\u0001\u0000\u0000\u0000\u03ce"+ | |
| "\u03cf\u0001\u0000\u0000\u0000\u03cf\u03d1\u0001\u0000\u0000\u0000\u03d0"+ | |
| "\u03ce\u0001\u0000\u0000\u0000\u03d1\u03d2\u00057\u0000\u0000\u03d2=\u0001"+ | |
| "\u0000\u0000\u0000\u03d3\u03d4\u0005\u0005\u0000\u0000\u03d4\u03d5\u0005"+ | |
| "9\u0000\u0000\u03d5\u03d9\u0005C\u0000\u0000\u03d6\u03d8\u0007\u0000\u0000"+ | |
| "\u0000\u03d7\u03d6\u0001\u0000\u0000\u0000\u03d8\u03db\u0001\u0000\u0000"+ | |
| "\u0000\u03d9\u03d7\u0001\u0000\u0000\u0000\u03d9\u03da\u0001\u0000\u0000"+ | |
| "\u0000\u03da\u03dc\u0001\u0000\u0000\u0000\u03db\u03d9\u0001\u0000\u0000"+ | |
| "\u0000\u03dc\u03dd\u00057\u0000\u0000\u03dd?\u0001\u0000\u0000\u0000\u03de"+ | |
| "\u040f\u0003<\u001e\u0000\u03df\u040e\u0003\n\u0005\u0000\u03e0\u040e"+ | |
| "\u0003f3\u0000\u03e1\u040e\u0003\u0010\b\u0000\u03e2\u040e\u0003\u0016"+ | |
| "\u000b\u0000\u03e3\u040e\u0003\u001c\u000e\u0000\u03e4\u040e\u0003\"\u0011"+ | |
| "\u0000\u03e5\u040e\u0003(\u0014\u0000\u03e6\u040e\u0003.\u0017\u0000\u03e7"+ | |
| "\u040e\u00034\u001a\u0000\u03e8\u040e\u0003:\u001d\u0000\u03e9\u040e\u0003"+ | |
| "F#\u0000\u03ea\u040e\u0003L&\u0000\u03eb\u040e\u0003R)\u0000\u03ec\u040e"+ | |
| "\u0003X,\u0000\u03ed\u040e\u0003d2\u0000\u03ee\u040e\u0003^/\u0000\u03ef"+ | |
| "\u040e\u0003\u00a4R\u0000\u03f0\u040e\u0003\u00aaU\u0000\u03f1\u040e\u0003"+ | |
| "\u00b0X\u0000\u03f2\u040e\u0003\u00b6[\u0000\u03f3\u040e\u0003\u00bc^"+ | |
| "\u0000\u03f4\u040e\u0003\f\u0006\u0000\u03f5\u040e\u0003\u0012\t\u0000"+ | |
| "\u03f6\u040e\u0003\u0018\f\u0000\u03f7\u040e\u0003\u001e\u000f\u0000\u03f8"+ | |
| "\u040e\u0003$\u0012\u0000\u03f9\u040e\u0003*\u0015\u0000\u03fa\u040e\u0003"+ | |
| "0\u0018\u0000\u03fb\u040e\u00036\u001b\u0000\u03fc\u040e\u0003B!\u0000"+ | |
| "\u03fd\u040e\u0003H$\u0000\u03fe\u040e\u0003N\'\u0000\u03ff\u040e\u0003"+ | |
| "T*\u0000\u0400\u040e\u0003`0\u0000\u0401\u040e\u0003Z-\u0000\u0402\u040e"+ | |
| "\u0003\u00a0P\u0000\u0403\u040e\u0003\u00a6S\u0000\u0404\u040e\u0003\u00ac"+ | |
| "V\u0000\u0405\u040e\u0003\u00b2Y\u0000\u0406\u040e\u0003\u00b8\\\u0000"+ | |
| "\u0407\u0408\u0004 \u000b\u0000\u0408\u040e\u0005\u0001\u0000\u0000\u0409"+ | |
| "\u040e\u0003\u0092I\u0000\u040a\u040e\u0005\u0006\u0000\u0000\u040b\u040e"+ | |
| "\u0003\u0094J\u0000\u040c\u040e\u0003\u0090H\u0000\u040d\u03df\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u03e0\u0001\u0000\u0000\u0000\u040d\u03e1\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u03e2\u0001\u0000\u0000\u0000\u040d\u03e3\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u03e4\u0001\u0000\u0000\u0000\u040d\u03e5\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u03e6\u0001\u0000\u0000\u0000\u040d\u03e7\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u03e8\u0001\u0000\u0000\u0000\u040d\u03e9\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u03ea\u0001\u0000\u0000\u0000\u040d\u03eb\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u03ec\u0001\u0000\u0000\u0000\u040d\u03ed\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u03ee\u0001\u0000\u0000\u0000\u040d\u03ef\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u03f0\u0001\u0000\u0000\u0000\u040d\u03f1\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u03f2\u0001\u0000\u0000\u0000\u040d\u03f3\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u03f4\u0001\u0000\u0000\u0000\u040d\u03f5\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u03f6\u0001\u0000\u0000\u0000\u040d\u03f7\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u03f8\u0001\u0000\u0000\u0000\u040d\u03f9\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u03fa\u0001\u0000\u0000\u0000\u040d\u03fb\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u03fc\u0001\u0000\u0000\u0000\u040d\u03fd\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u03fe\u0001\u0000\u0000\u0000\u040d\u03ff\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u0400\u0001\u0000\u0000\u0000\u040d\u0401\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u0402\u0001\u0000\u0000\u0000\u040d\u0403\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u0404\u0001\u0000\u0000\u0000\u040d\u0405\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u0406\u0001\u0000\u0000\u0000\u040d\u0407\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u0409\u0001\u0000\u0000\u0000\u040d\u040a\u0001\u0000"+ | |
| "\u0000\u0000\u040d\u040b\u0001\u0000\u0000\u0000\u040d\u040c\u0001\u0000"+ | |
| "\u0000\u0000\u040e\u0411\u0001\u0000\u0000\u0000\u040f\u040d\u0001\u0000"+ | |
| "\u0000\u0000\u040f\u0410\u0001\u0000\u0000\u0000\u0410\u0412\u0001\u0000"+ | |
| "\u0000\u0000\u0411\u040f\u0001\u0000\u0000\u0000\u0412\u0413\u0003>\u001f"+ | |
| "\u0000\u0413A\u0001\u0000\u0000\u0000\u0414\u0415\u0005\u0005\u0000\u0000"+ | |
| "\u0415\u041c\u0005D\u0000\u0000\u0416\u041b\u0003\b\u0004\u0000\u0417"+ | |
| "\u041b\u0005\u0006\u0000\u0000\u0418\u041b\u0005\u0001\u0000\u0000\u0419"+ | |
| "\u041b\u0005\u0004\u0000\u0000\u041a\u0416\u0001\u0000\u0000\u0000\u041a"+ | |
| "\u0417\u0001\u0000\u0000\u0000\u041a\u0418\u0001\u0000\u0000\u0000\u041a"+ | |
| "\u0419\u0001\u0000\u0000\u0000\u041b\u041e\u0001\u0000\u0000\u0000\u041c"+ | |
| "\u041a\u0001\u0000\u0000\u0000\u041c\u041d\u0001\u0000\u0000\u0000\u041d"+ | |
| "\u041f\u0001\u0000\u0000\u0000\u041e\u041c\u0001\u0000\u0000\u0000\u041f"+ | |
| "\u0420\u00057\u0000\u0000\u0420C\u0001\u0000\u0000\u0000\u0421\u0422\u0005"+ | |
| "\u0005\u0000\u0000\u0422\u0423\u00059\u0000\u0000\u0423\u0427\u0005D\u0000"+ | |
| "\u0000\u0424\u0426\u0007\u0000\u0000\u0000\u0425\u0424\u0001\u0000\u0000"+ | |
| "\u0000\u0426\u0429\u0001\u0000\u0000\u0000\u0427\u0425\u0001\u0000\u0000"+ | |
| "\u0000\u0427\u0428\u0001\u0000\u0000\u0000\u0428\u042a\u0001\u0000\u0000"+ | |
| "\u0000\u0429\u0427\u0001\u0000\u0000\u0000\u042a\u042b\u00057\u0000\u0000"+ | |
| "\u042bE\u0001\u0000\u0000\u0000\u042c\u045d\u0003B!\u0000\u042d\u045c"+ | |
| "\u0003\n\u0005\u0000\u042e\u045c\u0003f3\u0000\u042f\u045c\u0003\u0010"+ | |
| "\b\u0000\u0430\u045c\u0003\u0016\u000b\u0000\u0431\u045c\u0003\u001c\u000e"+ | |
| "\u0000\u0432\u045c\u0003\"\u0011\u0000\u0433\u045c\u0003(\u0014\u0000"+ | |
| "\u0434\u045c\u0003.\u0017\u0000\u0435\u045c\u00034\u001a\u0000\u0436\u045c"+ | |
| "\u0003:\u001d\u0000\u0437\u045c\u0003@ \u0000\u0438\u045c\u0003L&\u0000"+ | |
| "\u0439\u045c\u0003R)\u0000\u043a\u045c\u0003X,\u0000\u043b\u045c\u0003"+ | |
| "d2\u0000\u043c\u045c\u0003^/\u0000\u043d\u045c\u0003\u00a4R\u0000\u043e"+ | |
| "\u045c\u0003\u00aaU\u0000\u043f\u045c\u0003\u00b0X\u0000\u0440\u045c\u0003"+ | |
| "\u00b6[\u0000\u0441\u045c\u0003\u00bc^\u0000\u0442\u045c\u0003\f\u0006"+ | |
| "\u0000\u0443\u045c\u0003\u0012\t\u0000\u0444\u045c\u0003\u0018\f\u0000"+ | |
| "\u0445\u045c\u0003\u001e\u000f\u0000\u0446\u045c\u0003$\u0012\u0000\u0447"+ | |
| "\u045c\u0003*\u0015\u0000\u0448\u045c\u00030\u0018\u0000\u0449\u045c\u0003"+ | |
| "6\u001b\u0000\u044a\u045c\u0003<\u001e\u0000\u044b\u045c\u0003H$\u0000"+ | |
| "\u044c\u045c\u0003N\'\u0000\u044d\u045c\u0003T*\u0000\u044e\u045c\u0003"+ | |
| "`0\u0000\u044f\u045c\u0003Z-\u0000\u0450\u045c\u0003\u00a0P\u0000\u0451"+ | |
| "\u045c\u0003\u00a6S\u0000\u0452\u045c\u0003\u00acV\u0000\u0453\u045c\u0003"+ | |
| "\u00b2Y\u0000\u0454\u045c\u0003\u00b8\\\u0000\u0455\u0456\u0004#\f\u0000"+ | |
| "\u0456\u045c\u0005\u0001\u0000\u0000\u0457\u045c\u0003\u0092I\u0000\u0458"+ | |
| "\u045c\u0005\u0006\u0000\u0000\u0459\u045c\u0003\u0094J\u0000\u045a\u045c"+ | |
| "\u0003\u0090H\u0000\u045b\u042d\u0001\u0000\u0000\u0000\u045b\u042e\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u042f\u0001\u0000\u0000\u0000\u045b\u0430\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u0431\u0001\u0000\u0000\u0000\u045b\u0432\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u0433\u0001\u0000\u0000\u0000\u045b\u0434\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u0435\u0001\u0000\u0000\u0000\u045b\u0436\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u0437\u0001\u0000\u0000\u0000\u045b\u0438\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u0439\u0001\u0000\u0000\u0000\u045b\u043a\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u043b\u0001\u0000\u0000\u0000\u045b\u043c\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u043d\u0001\u0000\u0000\u0000\u045b\u043e\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u043f\u0001\u0000\u0000\u0000\u045b\u0440\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u0441\u0001\u0000\u0000\u0000\u045b\u0442\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u0443\u0001\u0000\u0000\u0000\u045b\u0444\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u0445\u0001\u0000\u0000\u0000\u045b\u0446\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u0447\u0001\u0000\u0000\u0000\u045b\u0448\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u0449\u0001\u0000\u0000\u0000\u045b\u044a\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u044b\u0001\u0000\u0000\u0000\u045b\u044c\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u044d\u0001\u0000\u0000\u0000\u045b\u044e\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u044f\u0001\u0000\u0000\u0000\u045b\u0450\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u0451\u0001\u0000\u0000\u0000\u045b\u0452\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u0453\u0001\u0000\u0000\u0000\u045b\u0454\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u0455\u0001\u0000\u0000\u0000\u045b\u0457\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u0458\u0001\u0000\u0000\u0000\u045b\u0459\u0001"+ | |
| "\u0000\u0000\u0000\u045b\u045a\u0001\u0000\u0000\u0000\u045c\u045f\u0001"+ | |
| "\u0000\u0000\u0000\u045d\u045b\u0001\u0000\u0000\u0000\u045d\u045e\u0001"+ | |
| "\u0000\u0000\u0000\u045e\u0460\u0001\u0000\u0000\u0000\u045f\u045d\u0001"+ | |
| "\u0000\u0000\u0000\u0460\u0461\u0003D\"\u0000\u0461G\u0001\u0000\u0000"+ | |
| "\u0000\u0462\u0463\u0005\u0005\u0000\u0000\u0463\u046a\u0005E\u0000\u0000"+ | |
| "\u0464\u0469\u0003\b\u0004\u0000\u0465\u0469\u0005\u0006\u0000\u0000\u0466"+ | |
| "\u0469\u0005\u0001\u0000\u0000\u0467\u0469\u0005\u0004\u0000\u0000\u0468"+ | |
| "\u0464\u0001\u0000\u0000\u0000\u0468\u0465\u0001\u0000\u0000\u0000\u0468"+ | |
| "\u0466\u0001\u0000\u0000\u0000\u0468\u0467\u0001\u0000\u0000\u0000\u0469"+ | |
| "\u046c\u0001\u0000\u0000\u0000\u046a\u0468\u0001\u0000\u0000\u0000\u046a"+ | |
| "\u046b\u0001\u0000\u0000\u0000\u046b\u046d\u0001\u0000\u0000\u0000\u046c"+ | |
| "\u046a\u0001\u0000\u0000\u0000\u046d\u046e\u00057\u0000\u0000\u046eI\u0001"+ | |
| "\u0000\u0000\u0000\u046f\u0470\u0005\u0005\u0000\u0000\u0470\u0471\u0005"+ | |
| "9\u0000\u0000\u0471\u0475\u0005E\u0000\u0000\u0472\u0474\u0007\u0000\u0000"+ | |
| "\u0000\u0473\u0472\u0001\u0000\u0000\u0000\u0474\u0477\u0001\u0000\u0000"+ | |
| "\u0000\u0475\u0473\u0001\u0000\u0000\u0000\u0475\u0476\u0001\u0000\u0000"+ | |
| "\u0000\u0476\u0478\u0001\u0000\u0000\u0000\u0477\u0475\u0001\u0000\u0000"+ | |
| "\u0000\u0478\u0479\u00057\u0000\u0000\u0479K\u0001\u0000\u0000\u0000\u047a"+ | |
| "\u04ab\u0003H$\u0000\u047b\u04aa\u0003\n\u0005\u0000\u047c\u04aa\u0003"+ | |
| "f3\u0000\u047d\u04aa\u0003\u0010\b\u0000\u047e\u04aa\u0003\u0016\u000b"+ | |
| "\u0000\u047f\u04aa\u0003\u001c\u000e\u0000\u0480\u04aa\u0003\"\u0011\u0000"+ | |
| "\u0481\u04aa\u0003(\u0014\u0000\u0482\u04aa\u0003.\u0017\u0000\u0483\u04aa"+ | |
| "\u00034\u001a\u0000\u0484\u04aa\u0003:\u001d\u0000\u0485\u04aa\u0003@"+ | |
| " \u0000\u0486\u04aa\u0003F#\u0000\u0487\u04aa\u0003R)\u0000\u0488\u04aa"+ | |
| "\u0003X,\u0000\u0489\u04aa\u0003d2\u0000\u048a\u04aa\u0003^/\u0000\u048b"+ | |
| "\u04aa\u0003\u00a4R\u0000\u048c\u04aa\u0003\u00aaU\u0000\u048d\u04aa\u0003"+ | |
| "\u00b0X\u0000\u048e\u04aa\u0003\u00b6[\u0000\u048f\u04aa\u0003\u00bc^"+ | |
| "\u0000\u0490\u04aa\u0003\f\u0006\u0000\u0491\u04aa\u0003\u0012\t\u0000"+ | |
| "\u0492\u04aa\u0003\u0018\f\u0000\u0493\u04aa\u0003\u001e\u000f\u0000\u0494"+ | |
| "\u04aa\u0003$\u0012\u0000\u0495\u04aa\u0003*\u0015\u0000\u0496\u04aa\u0003"+ | |
| "0\u0018\u0000\u0497\u04aa\u00036\u001b\u0000\u0498\u04aa\u0003<\u001e"+ | |
| "\u0000\u0499\u04aa\u0003B!\u0000\u049a\u04aa\u0003N\'\u0000\u049b\u04aa"+ | |
| "\u0003T*\u0000\u049c\u04aa\u0003`0\u0000\u049d\u04aa\u0003Z-\u0000\u049e"+ | |
| "\u04aa\u0003\u00a0P\u0000\u049f\u04aa\u0003\u00a6S\u0000\u04a0\u04aa\u0003"+ | |
| "\u00acV\u0000\u04a1\u04aa\u0003\u00b2Y\u0000\u04a2\u04aa\u0003\u00b8\\"+ | |
| "\u0000\u04a3\u04a4\u0004&\r\u0000\u04a4\u04aa\u0005\u0001\u0000\u0000"+ | |
| "\u04a5\u04aa\u0003\u0092I\u0000\u04a6\u04aa\u0005\u0006\u0000\u0000\u04a7"+ | |
| "\u04aa\u0003\u0094J\u0000\u04a8\u04aa\u0003\u0090H\u0000\u04a9\u047b\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u047c\u0001\u0000\u0000\u0000\u04a9\u047d\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u047e\u0001\u0000\u0000\u0000\u04a9\u047f\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u0480\u0001\u0000\u0000\u0000\u04a9\u0481\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u0482\u0001\u0000\u0000\u0000\u04a9\u0483\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u0484\u0001\u0000\u0000\u0000\u04a9\u0485\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u0486\u0001\u0000\u0000\u0000\u04a9\u0487\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u0488\u0001\u0000\u0000\u0000\u04a9\u0489\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u048a\u0001\u0000\u0000\u0000\u04a9\u048b\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u048c\u0001\u0000\u0000\u0000\u04a9\u048d\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u048e\u0001\u0000\u0000\u0000\u04a9\u048f\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u0490\u0001\u0000\u0000\u0000\u04a9\u0491\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u0492\u0001\u0000\u0000\u0000\u04a9\u0493\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u0494\u0001\u0000\u0000\u0000\u04a9\u0495\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u0496\u0001\u0000\u0000\u0000\u04a9\u0497\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u0498\u0001\u0000\u0000\u0000\u04a9\u0499\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u049a\u0001\u0000\u0000\u0000\u04a9\u049b\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u049c\u0001\u0000\u0000\u0000\u04a9\u049d\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u049e\u0001\u0000\u0000\u0000\u04a9\u049f\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u04a0\u0001\u0000\u0000\u0000\u04a9\u04a1\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u04a2\u0001\u0000\u0000\u0000\u04a9\u04a3\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u04a5\u0001\u0000\u0000\u0000\u04a9\u04a6\u0001"+ | |
| "\u0000\u0000\u0000\u04a9\u04a7\u0001\u0000\u0000\u0000\u04a9\u04a8\u0001"+ | |
| "\u0000\u0000\u0000\u04aa\u04ad\u0001\u0000\u0000\u0000\u04ab\u04a9\u0001"+ | |
| "\u0000\u0000\u0000\u04ab\u04ac\u0001\u0000\u0000\u0000\u04ac\u04ae\u0001"+ | |
| "\u0000\u0000\u0000\u04ad\u04ab\u0001\u0000\u0000\u0000\u04ae\u04af\u0003"+ | |
| "J%\u0000\u04afM\u0001\u0000\u0000\u0000\u04b0\u04b1\u0005\u0005\u0000"+ | |
| "\u0000\u04b1\u04b8\u0005F\u0000\u0000\u04b2\u04b7\u0003\b\u0004\u0000"+ | |
| "\u04b3\u04b7\u0005\u0006\u0000\u0000\u04b4\u04b7\u0005\u0001\u0000\u0000"+ | |
| "\u04b5\u04b7\u0005\u0004\u0000\u0000\u04b6\u04b2\u0001\u0000\u0000\u0000"+ | |
| "\u04b6\u04b3\u0001\u0000\u0000\u0000\u04b6\u04b4\u0001\u0000\u0000\u0000"+ | |
| "\u04b6\u04b5\u0001\u0000\u0000\u0000\u04b7\u04ba\u0001\u0000\u0000\u0000"+ | |
| "\u04b8\u04b6\u0001\u0000\u0000\u0000\u04b8\u04b9\u0001\u0000\u0000\u0000"+ | |
| "\u04b9\u04bb\u0001\u0000\u0000\u0000\u04ba\u04b8\u0001\u0000\u0000\u0000"+ | |
| "\u04bb\u04bc\u00057\u0000\u0000\u04bcO\u0001\u0000\u0000\u0000\u04bd\u04be"+ | |
| "\u0005\u0005\u0000\u0000\u04be\u04bf\u00059\u0000\u0000\u04bf\u04c3\u0005"+ | |
| "F\u0000\u0000\u04c0\u04c2\u0007\u0000\u0000\u0000\u04c1\u04c0\u0001\u0000"+ | |
| "\u0000\u0000\u04c2\u04c5\u0001\u0000\u0000\u0000\u04c3\u04c1\u0001\u0000"+ | |
| "\u0000\u0000\u04c3\u04c4\u0001\u0000\u0000\u0000\u04c4\u04c6\u0001\u0000"+ | |
| "\u0000\u0000\u04c5\u04c3\u0001\u0000\u0000\u0000\u04c6\u04c7\u00057\u0000"+ | |
| "\u0000\u04c7Q\u0001\u0000\u0000\u0000\u04c8\u04f9\u0003N\'\u0000\u04c9"+ | |
| "\u04f8\u0003\n\u0005\u0000\u04ca\u04f8\u0003f3\u0000\u04cb\u04f8\u0003"+ | |
| "\u0010\b\u0000\u04cc\u04f8\u0003\u0016\u000b\u0000\u04cd\u04f8\u0003\u001c"+ | |
| "\u000e\u0000\u04ce\u04f8\u0003\"\u0011\u0000\u04cf\u04f8\u0003(\u0014"+ | |
| "\u0000\u04d0\u04f8\u0003.\u0017\u0000\u04d1\u04f8\u00034\u001a\u0000\u04d2"+ | |
| "\u04f8\u0003:\u001d\u0000\u04d3\u04f8\u0003@ \u0000\u04d4\u04f8\u0003"+ | |
| "F#\u0000\u04d5\u04f8\u0003L&\u0000\u04d6\u04f8\u0003X,\u0000\u04d7\u04f8"+ | |
| "\u0003d2\u0000\u04d8\u04f8\u0003^/\u0000\u04d9\u04f8\u0003\u00a4R\u0000"+ | |
| "\u04da\u04f8\u0003\u00aaU\u0000\u04db\u04f8\u0003\u00b0X\u0000\u04dc\u04f8"+ | |
| "\u0003\u00b6[\u0000\u04dd\u04f8\u0003\u00bc^\u0000\u04de\u04f8\u0003\f"+ | |
| "\u0006\u0000\u04df\u04f8\u0003\u0012\t\u0000\u04e0\u04f8\u0003\u0018\f"+ | |
| "\u0000\u04e1\u04f8\u0003\u001e\u000f\u0000\u04e2\u04f8\u0003$\u0012\u0000"+ | |
| "\u04e3\u04f8\u0003*\u0015\u0000\u04e4\u04f8\u00030\u0018\u0000\u04e5\u04f8"+ | |
| "\u00036\u001b\u0000\u04e6\u04f8\u0003<\u001e\u0000\u04e7\u04f8\u0003B"+ | |
| "!\u0000\u04e8\u04f8\u0003H$\u0000\u04e9\u04f8\u0003T*\u0000\u04ea\u04f8"+ | |
| "\u0003`0\u0000\u04eb\u04f8\u0003Z-\u0000\u04ec\u04f8\u0003\u00a0P\u0000"+ | |
| "\u04ed\u04f8\u0003\u00a6S\u0000\u04ee\u04f8\u0003\u00acV\u0000\u04ef\u04f8"+ | |
| "\u0003\u00b2Y\u0000\u04f0\u04f8\u0003\u00b8\\\u0000\u04f1\u04f2\u0004"+ | |
| ")\u000e\u0000\u04f2\u04f8\u0005\u0001\u0000\u0000\u04f3\u04f8\u0003\u0092"+ | |
| "I\u0000\u04f4\u04f8\u0005\u0006\u0000\u0000\u04f5\u04f8\u0003\u0094J\u0000"+ | |
| "\u04f6\u04f8\u0003\u0090H\u0000\u04f7\u04c9\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04ca\u0001\u0000\u0000\u0000\u04f7\u04cb\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04cc\u0001\u0000\u0000\u0000\u04f7\u04cd\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04ce\u0001\u0000\u0000\u0000\u04f7\u04cf\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04d0\u0001\u0000\u0000\u0000\u04f7\u04d1\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04d2\u0001\u0000\u0000\u0000\u04f7\u04d3\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04d4\u0001\u0000\u0000\u0000\u04f7\u04d5\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04d6\u0001\u0000\u0000\u0000\u04f7\u04d7\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04d8\u0001\u0000\u0000\u0000\u04f7\u04d9\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04da\u0001\u0000\u0000\u0000\u04f7\u04db\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04dc\u0001\u0000\u0000\u0000\u04f7\u04dd\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04de\u0001\u0000\u0000\u0000\u04f7\u04df\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04e0\u0001\u0000\u0000\u0000\u04f7\u04e1\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04e2\u0001\u0000\u0000\u0000\u04f7\u04e3\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04e4\u0001\u0000\u0000\u0000\u04f7\u04e5\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04e6\u0001\u0000\u0000\u0000\u04f7\u04e7\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04e8\u0001\u0000\u0000\u0000\u04f7\u04e9\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04ea\u0001\u0000\u0000\u0000\u04f7\u04eb\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04ec\u0001\u0000\u0000\u0000\u04f7\u04ed\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04ee\u0001\u0000\u0000\u0000\u04f7\u04ef\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04f0\u0001\u0000\u0000\u0000\u04f7\u04f1\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04f3\u0001\u0000\u0000\u0000\u04f7\u04f4\u0001\u0000\u0000\u0000\u04f7"+ | |
| "\u04f5\u0001\u0000\u0000\u0000\u04f7\u04f6\u0001\u0000\u0000\u0000\u04f8"+ | |
| "\u04fb\u0001\u0000\u0000\u0000\u04f9\u04f7\u0001\u0000\u0000\u0000\u04f9"+ | |
| "\u04fa\u0001\u0000\u0000\u0000\u04fa\u04fc\u0001\u0000\u0000\u0000\u04fb"+ | |
| "\u04f9\u0001\u0000\u0000\u0000\u04fc\u04fd\u0003P(\u0000\u04fdS\u0001"+ | |
| "\u0000\u0000\u0000\u04fe\u04ff\u0005\u0005\u0000\u0000\u04ff\u0506\u0005"+ | |
| "G\u0000\u0000\u0500\u0505\u0003\b\u0004\u0000\u0501\u0505\u0005\u0006"+ | |
| "\u0000\u0000\u0502\u0505\u0005\u0001\u0000\u0000\u0503\u0505\u0005\u0004"+ | |
| "\u0000\u0000\u0504\u0500\u0001\u0000\u0000\u0000\u0504\u0501\u0001\u0000"+ | |
| "\u0000\u0000\u0504\u0502\u0001\u0000\u0000\u0000\u0504\u0503\u0001\u0000"+ | |
| "\u0000\u0000\u0505\u0508\u0001\u0000\u0000\u0000\u0506\u0504\u0001\u0000"+ | |
| "\u0000\u0000\u0506\u0507\u0001\u0000\u0000\u0000\u0507\u0509\u0001\u0000"+ | |
| "\u0000\u0000\u0508\u0506\u0001\u0000\u0000\u0000\u0509\u050a\u00057\u0000"+ | |
| "\u0000\u050aU\u0001\u0000\u0000\u0000\u050b\u050c\u0005\u0005\u0000\u0000"+ | |
| "\u050c\u050d\u00059\u0000\u0000\u050d\u0511\u0005G\u0000\u0000\u050e\u0510"+ | |
| "\u0007\u0000\u0000\u0000\u050f\u050e\u0001\u0000\u0000\u0000\u0510\u0513"+ | |
| "\u0001\u0000\u0000\u0000\u0511\u050f\u0001\u0000\u0000\u0000\u0511\u0512"+ | |
| "\u0001\u0000\u0000\u0000\u0512\u0514\u0001\u0000\u0000\u0000\u0513\u0511"+ | |
| "\u0001\u0000\u0000\u0000\u0514\u0515\u00057\u0000\u0000\u0515W\u0001\u0000"+ | |
| "\u0000\u0000\u0516\u0547\u0003T*\u0000\u0517\u0546\u0003\n\u0005\u0000"+ | |
| "\u0518\u0546\u0003f3\u0000\u0519\u0546\u0003\u0010\b\u0000\u051a\u0546"+ | |
| "\u0003\u0016\u000b\u0000\u051b\u0546\u0003\u001c\u000e\u0000\u051c\u0546"+ | |
| "\u0003\"\u0011\u0000\u051d\u0546\u0003(\u0014\u0000\u051e\u0546\u0003"+ | |
| ".\u0017\u0000\u051f\u0546\u00034\u001a\u0000\u0520\u0546\u0003:\u001d"+ | |
| "\u0000\u0521\u0546\u0003@ \u0000\u0522\u0546\u0003F#\u0000\u0523\u0546"+ | |
| "\u0003L&\u0000\u0524\u0546\u0003R)\u0000\u0525\u0546\u0003d2\u0000\u0526"+ | |
| "\u0546\u0003^/\u0000\u0527\u0546\u0003\u00a4R\u0000\u0528\u0546\u0003"+ | |
| "\u00aaU\u0000\u0529\u0546\u0003\u00b0X\u0000\u052a\u0546\u0003\u00b6["+ | |
| "\u0000\u052b\u0546\u0003\u00bc^\u0000\u052c\u0546\u0003\f\u0006\u0000"+ | |
| "\u052d\u0546\u0003\u0012\t\u0000\u052e\u0546\u0003\u0018\f\u0000\u052f"+ | |
| "\u0546\u0003\u001e\u000f\u0000\u0530\u0546\u0003$\u0012\u0000\u0531\u0546"+ | |
| "\u0003*\u0015\u0000\u0532\u0546\u00030\u0018\u0000\u0533\u0546\u00036"+ | |
| "\u001b\u0000\u0534\u0546\u0003<\u001e\u0000\u0535\u0546\u0003B!\u0000"+ | |
| "\u0536\u0546\u0003H$\u0000\u0537\u0546\u0003N\'\u0000\u0538\u0546\u0003"+ | |
| "`0\u0000\u0539\u0546\u0003Z-\u0000\u053a\u0546\u0003\u00a0P\u0000\u053b"+ | |
| "\u0546\u0003\u00a6S\u0000\u053c\u0546\u0003\u00acV\u0000\u053d\u0546\u0003"+ | |
| "\u00b2Y\u0000\u053e\u0546\u0003\u00b8\\\u0000\u053f\u0540\u0004,\u000f"+ | |
| "\u0000\u0540\u0546\u0005\u0001\u0000\u0000\u0541\u0546\u0003\u0092I\u0000"+ | |
| "\u0542\u0546\u0005\u0006\u0000\u0000\u0543\u0546\u0003\u0094J\u0000\u0544"+ | |
| "\u0546\u0003\u0090H\u0000\u0545\u0517\u0001\u0000\u0000\u0000\u0545\u0518"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u0519\u0001\u0000\u0000\u0000\u0545\u051a"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u051b\u0001\u0000\u0000\u0000\u0545\u051c"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u051d\u0001\u0000\u0000\u0000\u0545\u051e"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u051f\u0001\u0000\u0000\u0000\u0545\u0520"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u0521\u0001\u0000\u0000\u0000\u0545\u0522"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u0523\u0001\u0000\u0000\u0000\u0545\u0524"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u0525\u0001\u0000\u0000\u0000\u0545\u0526"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u0527\u0001\u0000\u0000\u0000\u0545\u0528"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u0529\u0001\u0000\u0000\u0000\u0545\u052a"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u052b\u0001\u0000\u0000\u0000\u0545\u052c"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u052d\u0001\u0000\u0000\u0000\u0545\u052e"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u052f\u0001\u0000\u0000\u0000\u0545\u0530"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u0531\u0001\u0000\u0000\u0000\u0545\u0532"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u0533\u0001\u0000\u0000\u0000\u0545\u0534"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u0535\u0001\u0000\u0000\u0000\u0545\u0536"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u0537\u0001\u0000\u0000\u0000\u0545\u0538"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u0539\u0001\u0000\u0000\u0000\u0545\u053a"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u053b\u0001\u0000\u0000\u0000\u0545\u053c"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u053d\u0001\u0000\u0000\u0000\u0545\u053e"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u053f\u0001\u0000\u0000\u0000\u0545\u0541"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u0542\u0001\u0000\u0000\u0000\u0545\u0543"+ | |
| "\u0001\u0000\u0000\u0000\u0545\u0544\u0001\u0000\u0000\u0000\u0546\u0549"+ | |
| "\u0001\u0000\u0000\u0000\u0547\u0545\u0001\u0000\u0000\u0000\u0547\u0548"+ | |
| "\u0001\u0000\u0000\u0000\u0548\u054a\u0001\u0000\u0000\u0000\u0549\u0547"+ | |
| "\u0001\u0000\u0000\u0000\u054a\u054b\u0003V+\u0000\u054bY\u0001\u0000"+ | |
| "\u0000\u0000\u054c\u054d\u0005\u0005\u0000\u0000\u054d\u0554\u0005H\u0000"+ | |
| "\u0000\u054e\u0553\u0003\b\u0004\u0000\u054f\u0553\u0005\u0006\u0000\u0000"+ | |
| "\u0550\u0553\u0005\u0001\u0000\u0000\u0551\u0553\u0005\u0004\u0000\u0000"+ | |
| "\u0552\u054e\u0001\u0000\u0000\u0000\u0552\u054f\u0001\u0000\u0000\u0000"+ | |
| "\u0552\u0550\u0001\u0000\u0000\u0000\u0552\u0551\u0001\u0000\u0000\u0000"+ | |
| "\u0553\u0556\u0001\u0000\u0000\u0000\u0554\u0552\u0001\u0000\u0000\u0000"+ | |
| "\u0554\u0555\u0001\u0000\u0000\u0000\u0555\u0557\u0001\u0000\u0000\u0000"+ | |
| "\u0556\u0554\u0001\u0000\u0000\u0000\u0557\u0558\u00057\u0000\u0000\u0558"+ | |
| "[\u0001\u0000\u0000\u0000\u0559\u055a\u0005\u0005\u0000\u0000\u055a\u055b"+ | |
| "\u00059\u0000\u0000\u055b\u055f\u0005H\u0000\u0000\u055c\u055e\u0007\u0000"+ | |
| "\u0000\u0000\u055d\u055c\u0001\u0000\u0000\u0000\u055e\u0561\u0001\u0000"+ | |
| "\u0000\u0000\u055f\u055d\u0001\u0000\u0000\u0000\u055f\u0560\u0001\u0000"+ | |
| "\u0000\u0000\u0560\u0562\u0001\u0000\u0000\u0000\u0561\u055f\u0001\u0000"+ | |
| "\u0000\u0000\u0562\u0563\u00057\u0000\u0000\u0563]\u0001\u0000\u0000\u0000"+ | |
| "\u0564\u0595\u0003Z-\u0000\u0565\u0594\u0003\n\u0005\u0000\u0566\u0594"+ | |
| "\u0003f3\u0000\u0567\u0594\u0003\u0010\b\u0000\u0568\u0594\u0003\u0016"+ | |
| "\u000b\u0000\u0569\u0594\u0003\u001c\u000e\u0000\u056a\u0594\u0003\"\u0011"+ | |
| "\u0000\u056b\u0594\u0003(\u0014\u0000\u056c\u0594\u0003.\u0017\u0000\u056d"+ | |
| "\u0594\u00034\u001a\u0000\u056e\u0594\u0003:\u001d\u0000\u056f\u0594\u0003"+ | |
| "@ \u0000\u0570\u0594\u0003F#\u0000\u0571\u0594\u0003L&\u0000\u0572\u0594"+ | |
| "\u0003R)\u0000\u0573\u0594\u0003X,\u0000\u0574\u0594\u0003d2\u0000\u0575"+ | |
| "\u0594\u0003\u00a4R\u0000\u0576\u0594\u0003\u00aaU\u0000\u0577\u0594\u0003"+ | |
| "\u00b0X\u0000\u0578\u0594\u0003\u00b6[\u0000\u0579\u0594\u0003\u00bc^"+ | |
| "\u0000\u057a\u0594\u0003\f\u0006\u0000\u057b\u0594\u0003\u0012\t\u0000"+ | |
| "\u057c\u0594\u0003\u0018\f\u0000\u057d\u0594\u0003\u001e\u000f\u0000\u057e"+ | |
| "\u0594\u0003$\u0012\u0000\u057f\u0594\u0003*\u0015\u0000\u0580\u0594\u0003"+ | |
| "0\u0018\u0000\u0581\u0594\u00036\u001b\u0000\u0582\u0594\u0003<\u001e"+ | |
| "\u0000\u0583\u0594\u0003B!\u0000\u0584\u0594\u0003H$\u0000\u0585\u0594"+ | |
| "\u0003N\'\u0000\u0586\u0594\u0003T*\u0000\u0587\u0594\u0003`0\u0000\u0588"+ | |
| "\u0594\u0003\u00a0P\u0000\u0589\u0594\u0003\u00a6S\u0000\u058a\u0594\u0003"+ | |
| "\u00acV\u0000\u058b\u0594\u0003\u00b2Y\u0000\u058c\u0594\u0003\u00b8\\"+ | |
| "\u0000\u058d\u058e\u0004/\u0010\u0000\u058e\u0594\u0005\u0001\u0000\u0000"+ | |
| "\u058f\u0594\u0003\u0092I\u0000\u0590\u0594\u0005\u0006\u0000\u0000\u0591"+ | |
| "\u0594\u0003\u0094J\u0000\u0592\u0594\u0003\u0090H\u0000\u0593\u0565\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u0566\u0001\u0000\u0000\u0000\u0593\u0567\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u0568\u0001\u0000\u0000\u0000\u0593\u0569\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u056a\u0001\u0000\u0000\u0000\u0593\u056b\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u056c\u0001\u0000\u0000\u0000\u0593\u056d\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u056e\u0001\u0000\u0000\u0000\u0593\u056f\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u0570\u0001\u0000\u0000\u0000\u0593\u0571\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u0572\u0001\u0000\u0000\u0000\u0593\u0573\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u0574\u0001\u0000\u0000\u0000\u0593\u0575\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u0576\u0001\u0000\u0000\u0000\u0593\u0577\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u0578\u0001\u0000\u0000\u0000\u0593\u0579\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u057a\u0001\u0000\u0000\u0000\u0593\u057b\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u057c\u0001\u0000\u0000\u0000\u0593\u057d\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u057e\u0001\u0000\u0000\u0000\u0593\u057f\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u0580\u0001\u0000\u0000\u0000\u0593\u0581\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u0582\u0001\u0000\u0000\u0000\u0593\u0583\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u0584\u0001\u0000\u0000\u0000\u0593\u0585\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u0586\u0001\u0000\u0000\u0000\u0593\u0587\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u0588\u0001\u0000\u0000\u0000\u0593\u0589\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u058a\u0001\u0000\u0000\u0000\u0593\u058b\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u058c\u0001\u0000\u0000\u0000\u0593\u058d\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u058f\u0001\u0000\u0000\u0000\u0593\u0590\u0001"+ | |
| "\u0000\u0000\u0000\u0593\u0591\u0001\u0000\u0000\u0000\u0593\u0592\u0001"+ | |
| "\u0000\u0000\u0000\u0594\u0597\u0001\u0000\u0000\u0000\u0595\u0593\u0001"+ | |
| "\u0000\u0000\u0000\u0595\u0596\u0001\u0000\u0000\u0000\u0596\u0598\u0001"+ | |
| "\u0000\u0000\u0000\u0597\u0595\u0001\u0000\u0000\u0000\u0598\u0599\u0003"+ | |
| "\\.\u0000\u0599_\u0001\u0000\u0000\u0000\u059a\u059b\u0005\u0005\u0000"+ | |
| "\u0000\u059b\u05a2\u0005I\u0000\u0000\u059c\u05a1\u0003\b\u0004\u0000"+ | |
| "\u059d\u05a1\u0005\u0006\u0000\u0000\u059e\u05a1\u0005\u0001\u0000\u0000"+ | |
| "\u059f\u05a1\u0005\u0004\u0000\u0000\u05a0\u059c\u0001\u0000\u0000\u0000"+ | |
| "\u05a0\u059d\u0001\u0000\u0000\u0000\u05a0\u059e\u0001\u0000\u0000\u0000"+ | |
| "\u05a0\u059f\u0001\u0000\u0000\u0000\u05a1\u05a4\u0001\u0000\u0000\u0000"+ | |
| "\u05a2\u05a0\u0001\u0000\u0000\u0000\u05a2\u05a3\u0001\u0000\u0000\u0000"+ | |
| "\u05a3\u05a5\u0001\u0000\u0000\u0000\u05a4\u05a2\u0001\u0000\u0000\u0000"+ | |
| "\u05a5\u05a6\u00057\u0000\u0000\u05a6a\u0001\u0000\u0000\u0000\u05a7\u05a8"+ | |
| "\u0005\u0005\u0000\u0000\u05a8\u05a9\u00059\u0000\u0000\u05a9\u05ad\u0005"+ | |
| "I\u0000\u0000\u05aa\u05ac\u0007\u0000\u0000\u0000\u05ab\u05aa\u0001\u0000"+ | |
| "\u0000\u0000\u05ac\u05af\u0001\u0000\u0000\u0000\u05ad\u05ab\u0001\u0000"+ | |
| "\u0000\u0000\u05ad\u05ae\u0001\u0000\u0000\u0000\u05ae\u05b0\u0001\u0000"+ | |
| "\u0000\u0000\u05af\u05ad\u0001\u0000\u0000\u0000\u05b0\u05b1\u00057\u0000"+ | |
| "\u0000\u05b1c\u0001\u0000\u0000\u0000\u05b2\u05e3\u0003`0\u0000\u05b3"+ | |
| "\u05e2\u0003\n\u0005\u0000\u05b4\u05e2\u0003f3\u0000\u05b5\u05e2\u0003"+ | |
| "\u0010\b\u0000\u05b6\u05e2\u0003\u0016\u000b\u0000\u05b7\u05e2\u0003\u001c"+ | |
| "\u000e\u0000\u05b8\u05e2\u0003\"\u0011\u0000\u05b9\u05e2\u0003(\u0014"+ | |
| "\u0000\u05ba\u05e2\u0003.\u0017\u0000\u05bb\u05e2\u00034\u001a\u0000\u05bc"+ | |
| "\u05e2\u0003:\u001d\u0000\u05bd\u05e2\u0003@ \u0000\u05be\u05e2\u0003"+ | |
| "F#\u0000\u05bf\u05e2\u0003L&\u0000\u05c0\u05e2\u0003R)\u0000\u05c1\u05e2"+ | |
| "\u0003X,\u0000\u05c2\u05e2\u0003^/\u0000\u05c3\u05e2\u0003\u00a4R\u0000"+ | |
| "\u05c4\u05e2\u0003\u00aaU\u0000\u05c5\u05e2\u0003\u00b0X\u0000\u05c6\u05e2"+ | |
| "\u0003\u00b6[\u0000\u05c7\u05e2\u0003\u00bc^\u0000\u05c8\u05e2\u0003\f"+ | |
| "\u0006\u0000\u05c9\u05e2\u0003\u0012\t\u0000\u05ca\u05e2\u0003\u0018\f"+ | |
| "\u0000\u05cb\u05e2\u0003\u001e\u000f\u0000\u05cc\u05e2\u0003$\u0012\u0000"+ | |
| "\u05cd\u05e2\u0003*\u0015\u0000\u05ce\u05e2\u00030\u0018\u0000\u05cf\u05e2"+ | |
| "\u00036\u001b\u0000\u05d0\u05e2\u0003<\u001e\u0000\u05d1\u05e2\u0003B"+ | |
| "!\u0000\u05d2\u05e2\u0003H$\u0000\u05d3\u05e2\u0003N\'\u0000\u05d4\u05e2"+ | |
| "\u0003T*\u0000\u05d5\u05e2\u0003Z-\u0000\u05d6\u05e2\u0003\u00a0P\u0000"+ | |
| "\u05d7\u05e2\u0003\u00a6S\u0000\u05d8\u05e2\u0003\u00acV\u0000\u05d9\u05e2"+ | |
| "\u0003\u00b2Y\u0000\u05da\u05e2\u0003\u00b8\\\u0000\u05db\u05dc\u0004"+ | |
| "2\u0011\u0000\u05dc\u05e2\u0005\u0001\u0000\u0000\u05dd\u05e2\u0003\u0092"+ | |
| "I\u0000\u05de\u05e2\u0005\u0006\u0000\u0000\u05df\u05e2\u0003\u0094J\u0000"+ | |
| "\u05e0\u05e2\u0003\u0090H\u0000\u05e1\u05b3\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05b4\u0001\u0000\u0000\u0000\u05e1\u05b5\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05b6\u0001\u0000\u0000\u0000\u05e1\u05b7\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05b8\u0001\u0000\u0000\u0000\u05e1\u05b9\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05ba\u0001\u0000\u0000\u0000\u05e1\u05bb\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05bc\u0001\u0000\u0000\u0000\u05e1\u05bd\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05be\u0001\u0000\u0000\u0000\u05e1\u05bf\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05c0\u0001\u0000\u0000\u0000\u05e1\u05c1\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05c2\u0001\u0000\u0000\u0000\u05e1\u05c3\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05c4\u0001\u0000\u0000\u0000\u05e1\u05c5\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05c6\u0001\u0000\u0000\u0000\u05e1\u05c7\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05c8\u0001\u0000\u0000\u0000\u05e1\u05c9\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05ca\u0001\u0000\u0000\u0000\u05e1\u05cb\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05cc\u0001\u0000\u0000\u0000\u05e1\u05cd\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05ce\u0001\u0000\u0000\u0000\u05e1\u05cf\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05d0\u0001\u0000\u0000\u0000\u05e1\u05d1\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05d2\u0001\u0000\u0000\u0000\u05e1\u05d3\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05d4\u0001\u0000\u0000\u0000\u05e1\u05d5\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05d6\u0001\u0000\u0000\u0000\u05e1\u05d7\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05d8\u0001\u0000\u0000\u0000\u05e1\u05d9\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05da\u0001\u0000\u0000\u0000\u05e1\u05db\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05dd\u0001\u0000\u0000\u0000\u05e1\u05de\u0001\u0000\u0000\u0000\u05e1"+ | |
| "\u05df\u0001\u0000\u0000\u0000\u05e1\u05e0\u0001\u0000\u0000\u0000\u05e2"+ | |
| "\u05e5\u0001\u0000\u0000\u0000\u05e3\u05e1\u0001\u0000\u0000\u0000\u05e3"+ | |
| "\u05e4\u0001\u0000\u0000\u0000\u05e4\u05e6\u0001\u0000\u0000\u0000\u05e5"+ | |
| "\u05e3\u0001\u0000\u0000\u0000\u05e6\u05e7\u0003b1\u0000\u05e7e\u0001"+ | |
| "\u0000\u0000\u0000\u05e8\u05fd\u0003h4\u0000\u05e9\u05fd\u0003j5\u0000"+ | |
| "\u05ea\u05fd\u0003l6\u0000\u05eb\u05fd\u0003n7\u0000\u05ec\u05fd\u0003"+ | |
| "p8\u0000\u05ed\u05fd\u0003r9\u0000\u05ee\u05fd\u0003t:\u0000\u05ef\u05fd"+ | |
| "\u0003v;\u0000\u05f0\u05fd\u0003x<\u0000\u05f1\u05fd\u0003z=\u0000\u05f2"+ | |
| "\u05fd\u0003|>\u0000\u05f3\u05fd\u0003~?\u0000\u05f4\u05fd\u0003\u0080"+ | |
| "@\u0000\u05f5\u05fd\u0003\u0082A\u0000\u05f6\u05fd\u0003\u0096K\u0000"+ | |
| "\u05f7\u05fd\u0003\u0098L\u0000\u05f8\u05fd\u0003\u009aM\u0000\u05f9\u05fd"+ | |
| "\u0003\u009cN\u0000\u05fa\u05fd\u0003\u009eO\u0000\u05fb\u05fd\u0003\u0084"+ | |
| "B\u0000\u05fc\u05e8\u0001\u0000\u0000\u0000\u05fc\u05e9\u0001\u0000\u0000"+ | |
| "\u0000\u05fc\u05ea\u0001\u0000\u0000\u0000\u05fc\u05eb\u0001\u0000\u0000"+ | |
| "\u0000\u05fc\u05ec\u0001\u0000\u0000\u0000\u05fc\u05ed\u0001\u0000\u0000"+ | |
| "\u0000\u05fc\u05ee\u0001\u0000\u0000\u0000\u05fc\u05ef\u0001\u0000\u0000"+ | |
| "\u0000\u05fc\u05f0\u0001\u0000\u0000\u0000\u05fc\u05f1\u0001\u0000\u0000"+ | |
| "\u0000\u05fc\u05f2\u0001\u0000\u0000\u0000\u05fc\u05f3\u0001\u0000\u0000"+ | |
| "\u0000\u05fc\u05f4\u0001\u0000\u0000\u0000\u05fc\u05f5\u0001\u0000\u0000"+ | |
| "\u0000\u05fc\u05f6\u0001\u0000\u0000\u0000\u05fc\u05f7\u0001\u0000\u0000"+ | |
| "\u0000\u05fc\u05f8\u0001\u0000\u0000\u0000\u05fc\u05f9\u0001\u0000\u0000"+ | |
| "\u0000\u05fc\u05fa\u0001\u0000\u0000\u0000\u05fc\u05fb\u0001\u0000\u0000"+ | |
| "\u0000\u05fdg\u0001\u0000\u0000\u0000\u05fe\u05ff\u0005\u0005\u0000\u0000"+ | |
| "\u05ff\u0606\u0007\u0001\u0000\u0000\u0600\u0605\u0003\b\u0004\u0000\u0601"+ | |
| "\u0605\u0005\u0006\u0000\u0000\u0602\u0605\u0005\u0001\u0000\u0000\u0603"+ | |
| "\u0605\u0005\u0004\u0000\u0000\u0604\u0600\u0001\u0000\u0000\u0000\u0604"+ | |
| "\u0601\u0001\u0000\u0000\u0000\u0604\u0602\u0001\u0000\u0000\u0000\u0604"+ | |
| "\u0603\u0001\u0000\u0000\u0000\u0605\u0608\u0001\u0000\u0000\u0000\u0606"+ | |
| "\u0604\u0001\u0000\u0000\u0000\u0606\u0607\u0001\u0000\u0000\u0000\u0607"+ | |
| "\u0609\u0001\u0000\u0000\u0000\u0608\u0606\u0001\u0000\u0000\u0000\u0609"+ | |
| "\u060a\u00058\u0000\u0000\u060ai\u0001\u0000\u0000\u0000\u060b\u060c\u0005"+ | |
| "\u0005\u0000\u0000\u060c\u0613\u0005J\u0000\u0000\u060d\u0612\u0003\b"+ | |
| "\u0004\u0000\u060e\u0612\u0005\u0006\u0000\u0000\u060f\u0612\u0005\u0001"+ | |
| "\u0000\u0000\u0610\u0612\u0005\u0004\u0000\u0000\u0611\u060d\u0001\u0000"+ | |
| "\u0000\u0000\u0611\u060e\u0001\u0000\u0000\u0000\u0611\u060f\u0001\u0000"+ | |
| "\u0000\u0000\u0611\u0610\u0001\u0000\u0000\u0000\u0612\u0615\u0001\u0000"+ | |
| "\u0000\u0000\u0613\u0611\u0001\u0000\u0000\u0000\u0613\u0614\u0001\u0000"+ | |
| "\u0000\u0000\u0614\u0616\u0001\u0000\u0000\u0000\u0615\u0613\u0001\u0000"+ | |
| "\u0000\u0000\u0616\u0617\u0007\u0002\u0000\u0000\u0617k\u0001\u0000\u0000"+ | |
| "\u0000\u0618\u0619\u0005\u0005\u0000\u0000\u0619\u0620\u0005K\u0000\u0000"+ | |
| "\u061a\u061f\u0003\b\u0004\u0000\u061b\u061f\u0005\u0006\u0000\u0000\u061c"+ | |
| "\u061f\u0005\u0001\u0000\u0000\u061d\u061f\u0005\u0004\u0000\u0000\u061e"+ | |
| "\u061a\u0001\u0000\u0000\u0000\u061e\u061b\u0001\u0000\u0000\u0000\u061e"+ | |
| "\u061c\u0001\u0000\u0000\u0000\u061e\u061d\u0001\u0000\u0000\u0000\u061f"+ | |
| "\u0622\u0001\u0000\u0000\u0000\u0620\u061e\u0001\u0000\u0000\u0000\u0620"+ | |
| "\u0621\u0001\u0000\u0000\u0000\u0621\u0623\u0001\u0000\u0000\u0000\u0622"+ | |
| "\u0620\u0001\u0000\u0000\u0000\u0623\u0624\u0007\u0002\u0000\u0000\u0624"+ | |
| "m\u0001\u0000\u0000\u0000\u0625\u0626\u0005\u0005\u0000\u0000\u0626\u062d"+ | |
| "\u0005L\u0000\u0000\u0627\u062c\u0003\b\u0004\u0000\u0628\u062c\u0005"+ | |
| "\u0006\u0000\u0000\u0629\u062c\u0005\u0001\u0000\u0000\u062a\u062c\u0005"+ | |
| "\u0004\u0000\u0000\u062b\u0627\u0001\u0000\u0000\u0000\u062b\u0628\u0001"+ | |
| "\u0000\u0000\u0000\u062b\u0629\u0001\u0000\u0000\u0000\u062b\u062a\u0001"+ | |
| "\u0000\u0000\u0000\u062c\u062f\u0001\u0000\u0000\u0000\u062d\u062b\u0001"+ | |
| "\u0000\u0000\u0000\u062d\u062e\u0001\u0000\u0000\u0000\u062e\u0630\u0001"+ | |
| "\u0000\u0000\u0000\u062f\u062d\u0001\u0000\u0000\u0000\u0630\u0631\u0007"+ | |
| "\u0002\u0000\u0000\u0631o\u0001\u0000\u0000\u0000\u0632\u0633\u0005\u0005"+ | |
| "\u0000\u0000\u0633\u063a\u0005M\u0000\u0000\u0634\u0639\u0003\b\u0004"+ | |
| "\u0000\u0635\u0639\u0005\u0006\u0000\u0000\u0636\u0639\u0005\u0001\u0000"+ | |
| "\u0000\u0637\u0639\u0005\u0004\u0000\u0000\u0638\u0634\u0001\u0000\u0000"+ | |
| "\u0000\u0638\u0635\u0001\u0000\u0000\u0000\u0638\u0636\u0001\u0000\u0000"+ | |
| "\u0000\u0638\u0637\u0001\u0000\u0000\u0000\u0639\u063c\u0001\u0000\u0000"+ | |
| "\u0000\u063a\u0638\u0001\u0000\u0000\u0000\u063a\u063b\u0001\u0000\u0000"+ | |
| "\u0000\u063b\u063d\u0001\u0000\u0000\u0000\u063c\u063a\u0001\u0000\u0000"+ | |
| "\u0000\u063d\u063e\u0007\u0002\u0000\u0000\u063eq\u0001\u0000\u0000\u0000"+ | |
| "\u063f\u0640\u0005\u0005\u0000\u0000\u0640\u0647\u0005N\u0000\u0000\u0641"+ | |
| "\u0646\u0003\b\u0004\u0000\u0642\u0646\u0005\u0006\u0000\u0000\u0643\u0646"+ | |
| "\u0005\u0001\u0000\u0000\u0644\u0646\u0005\u0004\u0000\u0000\u0645\u0641"+ | |
| "\u0001\u0000\u0000\u0000\u0645\u0642\u0001\u0000\u0000\u0000\u0645\u0643"+ | |
| "\u0001\u0000\u0000\u0000\u0645\u0644\u0001\u0000\u0000\u0000\u0646\u0649"+ | |
| "\u0001\u0000\u0000\u0000\u0647\u0645\u0001\u0000\u0000\u0000\u0647\u0648"+ | |
| "\u0001\u0000\u0000\u0000\u0648\u064a\u0001\u0000\u0000\u0000\u0649\u0647"+ | |
| "\u0001\u0000\u0000\u0000\u064a\u064b\u0007\u0002\u0000\u0000\u064bs\u0001"+ | |
| "\u0000\u0000\u0000\u064c\u064d\u0005\u0005\u0000\u0000\u064d\u0654\u0005"+ | |
| "O\u0000\u0000\u064e\u0653\u0003\b\u0004\u0000\u064f\u0653\u0005\u0006"+ | |
| "\u0000\u0000\u0650\u0653\u0005\u0001\u0000\u0000\u0651\u0653\u0005\u0004"+ | |
| "\u0000\u0000\u0652\u064e\u0001\u0000\u0000\u0000\u0652\u064f\u0001\u0000"+ | |
| "\u0000\u0000\u0652\u0650\u0001\u0000\u0000\u0000\u0652\u0651\u0001\u0000"+ | |
| "\u0000\u0000\u0653\u0656\u0001\u0000\u0000\u0000\u0654\u0652\u0001\u0000"+ | |
| "\u0000\u0000\u0654\u0655\u0001\u0000\u0000\u0000\u0655\u0657\u0001\u0000"+ | |
| "\u0000\u0000\u0656\u0654\u0001\u0000\u0000\u0000\u0657\u0658\u0007\u0002"+ | |
| "\u0000\u0000\u0658u\u0001\u0000\u0000\u0000\u0659\u065a\u0005\u0005\u0000"+ | |
| "\u0000\u065a\u0661\u0005P\u0000\u0000\u065b\u0660\u0003\b\u0004\u0000"+ | |
| "\u065c\u0660\u0005\u0006\u0000\u0000\u065d\u0660\u0005\u0001\u0000\u0000"+ | |
| "\u065e\u0660\u0005\u0004\u0000\u0000\u065f\u065b\u0001\u0000\u0000\u0000"+ | |
| "\u065f\u065c\u0001\u0000\u0000\u0000\u065f\u065d\u0001\u0000\u0000\u0000"+ | |
| "\u065f\u065e\u0001\u0000\u0000\u0000\u0660\u0663\u0001\u0000\u0000\u0000"+ | |
| "\u0661\u065f\u0001\u0000\u0000\u0000\u0661\u0662\u0001\u0000\u0000\u0000"+ | |
| "\u0662\u0664\u0001\u0000\u0000\u0000\u0663\u0661\u0001\u0000\u0000\u0000"+ | |
| "\u0664\u0665\u0007\u0002\u0000\u0000\u0665w\u0001\u0000\u0000\u0000\u0666"+ | |
| "\u0667\u0005\u0005\u0000\u0000\u0667\u066e\u0005Q\u0000\u0000\u0668\u066d"+ | |
| "\u0003\b\u0004\u0000\u0669\u066d\u0005\u0006\u0000\u0000\u066a\u066d\u0005"+ | |
| "\u0001\u0000\u0000\u066b\u066d\u0005\u0004\u0000\u0000\u066c\u0668\u0001"+ | |
| "\u0000\u0000\u0000\u066c\u0669\u0001\u0000\u0000\u0000\u066c\u066a\u0001"+ | |
| "\u0000\u0000\u0000\u066c\u066b\u0001\u0000\u0000\u0000\u066d\u0670\u0001"+ | |
| "\u0000\u0000\u0000\u066e\u066c\u0001\u0000\u0000\u0000\u066e\u066f\u0001"+ | |
| "\u0000\u0000\u0000\u066f\u0671\u0001\u0000\u0000\u0000\u0670\u066e\u0001"+ | |
| "\u0000\u0000\u0000\u0671\u0672\u0007\u0002\u0000\u0000\u0672y\u0001\u0000"+ | |
| "\u0000\u0000\u0673\u0674\u0005\u0005\u0000\u0000\u0674\u067b\u0005R\u0000"+ | |
| "\u0000\u0675\u067a\u0003\b\u0004\u0000\u0676\u067a\u0005\u0006\u0000\u0000"+ | |
| "\u0677\u067a\u0005\u0001\u0000\u0000\u0678\u067a\u0005\u0004\u0000\u0000"+ | |
| "\u0679\u0675\u0001\u0000\u0000\u0000\u0679\u0676\u0001\u0000\u0000\u0000"+ | |
| "\u0679\u0677\u0001\u0000\u0000\u0000\u0679\u0678\u0001\u0000\u0000\u0000"+ | |
| "\u067a\u067d\u0001\u0000\u0000\u0000\u067b\u0679\u0001\u0000\u0000\u0000"+ | |
| "\u067b\u067c\u0001\u0000\u0000\u0000\u067c\u067e\u0001\u0000\u0000\u0000"+ | |
| "\u067d\u067b\u0001\u0000\u0000\u0000\u067e\u067f\u0007\u0002\u0000\u0000"+ | |
| "\u067f{\u0001\u0000\u0000\u0000\u0680\u0681\u0005\u0005\u0000\u0000\u0681"+ | |
| "\u0688\u0005S\u0000\u0000\u0682\u0687\u0003\b\u0004\u0000\u0683\u0687"+ | |
| "\u0005\u0006\u0000\u0000\u0684\u0687\u0005\u0001\u0000\u0000\u0685\u0687"+ | |
| "\u0005\u0004\u0000\u0000\u0686\u0682\u0001\u0000\u0000\u0000\u0686\u0683"+ | |
| "\u0001\u0000\u0000\u0000\u0686\u0684\u0001\u0000\u0000\u0000\u0686\u0685"+ | |
| "\u0001\u0000\u0000\u0000\u0687\u068a\u0001\u0000\u0000\u0000\u0688\u0686"+ | |
| "\u0001\u0000\u0000\u0000\u0688\u0689\u0001\u0000\u0000\u0000\u0689\u068b"+ | |
| "\u0001\u0000\u0000\u0000\u068a\u0688\u0001\u0000\u0000\u0000\u068b\u068c"+ | |
| "\u0007\u0002\u0000\u0000\u068c}\u0001\u0000\u0000\u0000\u068d\u068e\u0005"+ | |
| "\u0005\u0000\u0000\u068e\u0695\u0005T\u0000\u0000\u068f\u0694\u0003\b"+ | |
| "\u0004\u0000\u0690\u0694\u0005\u0006\u0000\u0000\u0691\u0694\u0005\u0001"+ | |
| "\u0000\u0000\u0692\u0694\u0005\u0004\u0000\u0000\u0693\u068f\u0001\u0000"+ | |
| "\u0000\u0000\u0693\u0690\u0001\u0000\u0000\u0000\u0693\u0691\u0001\u0000"+ | |
| "\u0000\u0000\u0693\u0692\u0001\u0000\u0000\u0000\u0694\u0697\u0001\u0000"+ | |
| "\u0000\u0000\u0695\u0693\u0001\u0000\u0000\u0000\u0695\u0696\u0001\u0000"+ | |
| "\u0000\u0000\u0696\u0698\u0001\u0000\u0000\u0000\u0697\u0695\u0001\u0000"+ | |
| "\u0000\u0000\u0698\u0699\u0007\u0002\u0000\u0000\u0699\u007f\u0001\u0000"+ | |
| "\u0000\u0000\u069a\u069b\u0005\u0005\u0000\u0000\u069b\u06a2\u0005U\u0000"+ | |
| "\u0000\u069c\u06a1\u0003\b\u0004\u0000\u069d\u06a1\u0005\u0006\u0000\u0000"+ | |
| "\u069e\u06a1\u0005\u0001\u0000\u0000\u069f\u06a1\u0005\u0004\u0000\u0000"+ | |
| "\u06a0\u069c\u0001\u0000\u0000\u0000\u06a0\u069d\u0001\u0000\u0000\u0000"+ | |
| "\u06a0\u069e\u0001\u0000\u0000\u0000\u06a0\u069f\u0001\u0000\u0000\u0000"+ | |
| "\u06a1\u06a4\u0001\u0000\u0000\u0000\u06a2\u06a0\u0001\u0000\u0000\u0000"+ | |
| "\u06a2\u06a3\u0001\u0000\u0000\u0000\u06a3\u06a5\u0001\u0000\u0000\u0000"+ | |
| "\u06a4\u06a2\u0001\u0000\u0000\u0000\u06a5\u06a6\u0007\u0002\u0000\u0000"+ | |
| "\u06a6\u0081\u0001\u0000\u0000\u0000\u06a7\u06a8\u0005\u0005\u0000\u0000"+ | |
| "\u06a8\u06af\u0005V\u0000\u0000\u06a9\u06ae\u0003\b\u0004\u0000\u06aa"+ | |
| "\u06ae\u0005\u0006\u0000\u0000\u06ab\u06ae\u0005\u0001\u0000\u0000\u06ac"+ | |
| "\u06ae\u0005\u0004\u0000\u0000\u06ad\u06a9\u0001\u0000\u0000\u0000\u06ad"+ | |
| "\u06aa\u0001\u0000\u0000\u0000\u06ad\u06ab\u0001\u0000\u0000\u0000\u06ad"+ | |
| "\u06ac\u0001\u0000\u0000\u0000\u06ae\u06b1\u0001\u0000\u0000\u0000\u06af"+ | |
| "\u06ad\u0001\u0000\u0000\u0000\u06af\u06b0\u0001\u0000\u0000\u0000\u06b0"+ | |
| "\u06b2\u0001\u0000\u0000\u0000\u06b1\u06af\u0001\u0000\u0000\u0000\u06b2"+ | |
| "\u06b3\u0007\u0002\u0000\u0000\u06b3\u0083\u0001\u0000\u0000\u0000\u06b4"+ | |
| "\u06b5\u0005\u0005\u0000\u0000\u06b5\u06b6\u00059\u0000\u0000\u06b6\u06b7"+ | |
| "\u0003\u0086C\u0000\u06b7\u06b8\u00057\u0000\u0000\u06b8\u06b9\u0006B"+ | |
| "\uffff\uffff\u0000\u06b9\u0085\u0001\u0000\u0000\u0000\u06ba\u06bb\u0007"+ | |
| "\u0003\u0000\u0000\u06bb\u0087\u0001\u0000\u0000\u0000\u06bc\u06bd\u0004"+ | |
| "D\u0012\u0000\u06bd\u06c4\u0005\u0001\u0000\u0000\u06be\u06c4\u0003\u0092"+ | |
| "I\u0000\u06bf\u06c4\u0005\u0006\u0000\u0000\u06c0\u06c4\u0003\u0094J\u0000"+ | |
| "\u06c1\u06c4\u0003\u0090H\u0000\u06c2\u06c4\u0003\u0002\u0001\u0000\u06c3"+ | |
| "\u06bc\u0001\u0000\u0000\u0000\u06c3\u06be\u0001\u0000\u0000\u0000\u06c3"+ | |
| "\u06bf\u0001\u0000\u0000\u0000\u06c3\u06c0\u0001\u0000\u0000\u0000\u06c3"+ | |
| "\u06c1\u0001\u0000\u0000\u0000\u06c3\u06c2\u0001\u0000\u0000\u0000\u06c4"+ | |
| "\u06c5\u0001\u0000\u0000\u0000\u06c5\u06c3\u0001\u0000\u0000\u0000\u06c5"+ | |
| "\u06c6\u0001\u0000\u0000\u0000\u06c6\u0089\u0001\u0000\u0000\u0000\u06c7"+ | |
| "\u06cd\u0005\u001c\u0000\u0000\u06c8\u06c9\u0005\u001e\u0000\u0000\u06c9"+ | |
| "\u06cb\u0005!\u0000\u0000\u06ca\u06cc\u0003\u008cF\u0000\u06cb\u06ca\u0001"+ | |
| "\u0000\u0000\u0000\u06cb\u06cc\u0001\u0000\u0000\u0000\u06cc\u06ce\u0001"+ | |
| "\u0000\u0000\u0000\u06cd\u06c8\u0001\u0000\u0000\u0000\u06cd\u06ce\u0001"+ | |
| "\u0000\u0000\u0000\u06ce\u06d5\u0001\u0000\u0000\u0000\u06cf\u06d0\u0005"+ | |
| "\u001e\u0000\u0000\u06d0\u06d2\u0005!\u0000\u0000\u06d1\u06d3\u0003\u008c"+ | |
| "F\u0000\u06d2\u06d1\u0001\u0000\u0000\u0000\u06d2\u06d3\u0001\u0000\u0000"+ | |
| "\u0000\u06d3\u06d5\u0001\u0000\u0000\u0000\u06d4\u06c7\u0001\u0000\u0000"+ | |
| "\u0000\u06d4\u06cf\u0001\u0000\u0000\u0000\u06d5\u008b\u0001\u0000\u0000"+ | |
| "\u0000\u06d6\u06da\u0005\"\u0000\u0000\u06d7\u06d9\u0007\u0004\u0000\u0000"+ | |
| "\u06d8\u06d7\u0001\u0000\u0000\u0000\u06d9\u06dc\u0001\u0000\u0000\u0000"+ | |
| "\u06da\u06d8\u0001\u0000\u0000\u0000\u06da\u06db\u0001\u0000\u0000\u0000"+ | |
| "\u06db\u06dd\u0001\u0000\u0000\u0000\u06dc\u06da\u0001\u0000\u0000\u0000"+ | |
| "\u06dd\u06de\u0005#\u0000\u0000\u06de\u008d\u0001\u0000\u0000\u0000\u06df"+ | |
| "\u06e1\u0005\u0007\u0000\u0000\u06e0\u06e2\u0007\u0005\u0000\u0000\u06e1"+ | |
| "\u06e0\u0001\u0000\u0000\u0000\u06e2\u06e3\u0001\u0000\u0000\u0000\u06e3"+ | |
| "\u06e1\u0001\u0000\u0000\u0000\u06e3\u06e4\u0001\u0000\u0000\u0000\u06e4"+ | |
| "\u06e5\u0001\u0000\u0000\u0000\u06e5\u07a3\u0003\u0088D\u0000\u06e6\u06ea"+ | |
| "\u0005\b\u0000\u0000\u06e7\u06e9\u0007\u0005\u0000\u0000\u06e8\u06e7\u0001"+ | |
| "\u0000\u0000\u0000\u06e9\u06ec\u0001\u0000\u0000\u0000\u06ea\u06e8\u0001"+ | |
| "\u0000\u0000\u0000\u06ea\u06eb\u0001\u0000\u0000\u0000\u06eb\u06ef\u0001"+ | |
| "\u0000\u0000\u0000\u06ec\u06ea\u0001\u0000\u0000\u0000\u06ed\u06ee\u0007"+ | |
| "\u0005\u0000\u0000\u06ee\u06f0\u0003\u0088D\u0000\u06ef\u06ed\u0001\u0000"+ | |
| "\u0000\u0000\u06ef\u06f0\u0001\u0000\u0000\u0000\u06f0\u07a3\u0001\u0000"+ | |
| "\u0000\u0000\u06f1\u06f6\u0005\t\u0000\u0000\u06f2\u06f7\u0005\u0004\u0000"+ | |
| "\u0000\u06f3\u06f7\u0005\u0006\u0000\u0000\u06f4\u06f5\u0004G\u0013\u0000"+ | |
| "\u06f5\u06f7\u0005\u0001\u0000\u0000\u06f6\u06f2\u0001\u0000\u0000\u0000"+ | |
| "\u06f6\u06f3\u0001\u0000\u0000\u0000\u06f6\u06f4\u0001\u0000\u0000\u0000"+ | |
| "\u06f7\u06f8\u0001\u0000\u0000\u0000\u06f8\u06f6\u0001\u0000\u0000\u0000"+ | |
| "\u06f8\u06f9\u0001\u0000\u0000\u0000\u06f9\u06fa\u0001\u0000\u0000\u0000"+ | |
| "\u06fa\u06fe\u0005+\u0000\u0000\u06fb\u06fd\u0007\u0005\u0000\u0000\u06fc"+ | |
| "\u06fb\u0001\u0000\u0000\u0000\u06fd\u0700\u0001\u0000\u0000\u0000\u06fe"+ | |
| "\u06fc\u0001\u0000\u0000\u0000\u06fe\u06ff\u0001\u0000\u0000\u0000\u06ff"+ | |
| "\u0703\u0001\u0000\u0000\u0000\u0700\u06fe\u0001\u0000\u0000\u0000\u0701"+ | |
| "\u0702\u0007\u0005\u0000\u0000\u0702\u0704\u0003\u0088D\u0000\u0703\u0701"+ | |
| "\u0001\u0000\u0000\u0000\u0703\u0704\u0001\u0000\u0000\u0000\u0704\u07a3"+ | |
| "\u0001\u0000\u0000\u0000\u0705\u070a\u0005\n\u0000\u0000\u0706\u070b\u0005"+ | |
| "\u0004\u0000\u0000\u0707\u070b\u0005\u0006\u0000\u0000\u0708\u0709\u0004"+ | |
| "G\u0014\u0000\u0709\u070b\u0005\u0001\u0000\u0000\u070a\u0706\u0001\u0000"+ | |
| "\u0000\u0000\u070a\u0707\u0001\u0000\u0000\u0000\u070a\u0708\u0001\u0000"+ | |
| "\u0000\u0000\u070b\u070c\u0001\u0000\u0000\u0000\u070c\u070a\u0001\u0000"+ | |
| "\u0000\u0000\u070c\u070d\u0001\u0000\u0000\u0000\u070d\u070e\u0001\u0000"+ | |
| "\u0000\u0000\u070e\u0712\u0005\u0019\u0000\u0000\u070f\u0711\u0007\u0005"+ | |
| "\u0000\u0000\u0710\u070f\u0001\u0000\u0000\u0000\u0711\u0714\u0001\u0000"+ | |
| "\u0000\u0000\u0712\u0710\u0001\u0000\u0000\u0000\u0712\u0713\u0001\u0000"+ | |
| "\u0000\u0000\u0713\u0717\u0001\u0000\u0000\u0000\u0714\u0712\u0001\u0000"+ | |
| "\u0000\u0000\u0715\u0716\u0007\u0005\u0000\u0000\u0716\u0718\u0003\u0088"+ | |
| "D\u0000\u0717\u0715\u0001\u0000\u0000\u0000\u0717\u0718\u0001\u0000\u0000"+ | |
| "\u0000\u0718\u07a3\u0001\u0000\u0000\u0000\u0719\u071b\u0005\u000b\u0000"+ | |
| "\u0000\u071a\u071c\u0007\u0005\u0000\u0000\u071b\u071a\u0001\u0000\u0000"+ | |
| "\u0000\u071c\u071d\u0001\u0000\u0000\u0000\u071d\u071b\u0001\u0000\u0000"+ | |
| "\u0000\u071d\u071e\u0001\u0000\u0000\u0000\u071e\u071f\u0001\u0000\u0000"+ | |
| "\u0000\u071f\u07a3\u0003\u0088D\u0000\u0720\u0725\u0005\f\u0000\u0000"+ | |
| "\u0721\u0726\u0005\u0004\u0000\u0000\u0722\u0726\u0005\u0006\u0000\u0000"+ | |
| "\u0723\u0724\u0004G\u0015\u0000\u0724\u0726\u0005\u0001\u0000\u0000\u0725"+ | |
| "\u0721\u0001\u0000\u0000\u0000\u0725\u0722\u0001\u0000\u0000\u0000\u0725"+ | |
| "\u0723\u0001\u0000\u0000\u0000\u0726\u0727\u0001\u0000\u0000\u0000\u0727"+ | |
| "\u0725\u0001\u0000\u0000\u0000\u0727\u0728\u0001\u0000\u0000\u0000\u0728"+ | |
| "\u072c\u0001\u0000\u0000\u0000\u0729\u072d\u0003\u008aE\u0000\u072a\u072d"+ | |
| "\u0005\u001b\u0000\u0000\u072b\u072d\u0003\u0002\u0001\u0000\u072c\u0729"+ | |
| "\u0001\u0000\u0000\u0000\u072c\u072a\u0001\u0000\u0000\u0000\u072c\u072b"+ | |
| "\u0001\u0000\u0000\u0000\u072d\u0731\u0001\u0000\u0000\u0000\u072e\u0730"+ | |
| "\u0007\u0005\u0000\u0000\u072f\u072e\u0001\u0000\u0000\u0000\u0730\u0733"+ | |
| "\u0001\u0000\u0000\u0000\u0731\u072f\u0001\u0000\u0000\u0000\u0731\u0732"+ | |
| "\u0001\u0000\u0000\u0000\u0732\u0736\u0001\u0000\u0000\u0000\u0733\u0731"+ | |
| "\u0001\u0000\u0000\u0000\u0734\u0735\u0007\u0005\u0000\u0000\u0735\u0737"+ | |
| "\u0003\u0088D\u0000\u0736\u0734\u0001\u0000\u0000\u0000\u0736\u0737\u0001"+ | |
| "\u0000\u0000\u0000\u0737\u07a3\u0001\u0000\u0000\u0000\u0738\u073c\u0005"+ | |
| "\r\u0000\u0000\u0739\u073b\u0007\u0005\u0000\u0000\u073a\u0739\u0001\u0000"+ | |
| "\u0000\u0000\u073b\u073e\u0001\u0000\u0000\u0000\u073c\u073a\u0001\u0000"+ | |
| "\u0000\u0000\u073c\u073d\u0001\u0000\u0000\u0000\u073d\u0743\u0001\u0000"+ | |
| "\u0000\u0000\u073e\u073c\u0001\u0000\u0000\u0000\u073f\u0740\u0007\u0005"+ | |
| "\u0000\u0000\u0740\u0744\u0003\u0088D\u0000\u0741\u0744\u0005\u0016\u0000"+ | |
| "\u0000\u0742\u0744\u0005\u0017\u0000\u0000\u0743\u073f\u0001\u0000\u0000"+ | |
| "\u0000\u0743\u0741\u0001\u0000\u0000\u0000\u0743\u0742\u0001\u0000\u0000"+ | |
| "\u0000\u0743\u0744\u0001\u0000\u0000\u0000\u0744\u0748\u0001\u0000\u0000"+ | |
| "\u0000\u0745\u0747\u0007\u0005\u0000\u0000\u0746\u0745\u0001\u0000\u0000"+ | |
| "\u0000\u0747\u074a\u0001\u0000\u0000\u0000\u0748\u0746\u0001\u0000\u0000"+ | |
| "\u0000\u0748\u0749\u0001\u0000\u0000\u0000\u0749\u07a3\u0001\u0000\u0000"+ | |
| "\u0000\u074a\u0748\u0001\u0000\u0000\u0000\u074b\u074f\u0005\u000f\u0000"+ | |
| "\u0000\u074c\u074e\u0007\u0005\u0000\u0000\u074d\u074c\u0001\u0000\u0000"+ | |
| "\u0000\u074e\u0751\u0001\u0000\u0000\u0000\u074f\u074d\u0001\u0000\u0000"+ | |
| "\u0000\u074f\u0750\u0001\u0000\u0000\u0000\u0750\u0754\u0001\u0000\u0000"+ | |
| "\u0000\u0751\u074f\u0001\u0000\u0000\u0000\u0752\u0753\u0007\u0005\u0000"+ | |
| "\u0000\u0753\u0755\u0003\u0088D\u0000\u0754\u0752\u0001\u0000\u0000\u0000"+ | |
| "\u0754\u0755\u0001\u0000\u0000\u0000\u0755\u07a3\u0001\u0000\u0000\u0000"+ | |
| "\u0756\u075a\u0005\u000e\u0000\u0000\u0757\u0759\u0007\u0005\u0000\u0000"+ | |
| "\u0758\u0757\u0001\u0000\u0000\u0000\u0759\u075c\u0001\u0000\u0000\u0000"+ | |
| "\u075a\u0758\u0001\u0000\u0000\u0000\u075a\u075b\u0001\u0000\u0000\u0000"+ | |
| "\u075b\u075f\u0001\u0000\u0000\u0000\u075c\u075a\u0001\u0000\u0000\u0000"+ | |
| "\u075d\u075e\u0007\u0005\u0000\u0000\u075e\u0760\u0005\'\u0000\u0000\u075f"+ | |
| "\u075d\u0001\u0000\u0000\u0000\u075f\u0760\u0001\u0000\u0000\u0000\u0760"+ | |
| "\u0764\u0001\u0000\u0000\u0000\u0761\u0763\u0007\u0005\u0000\u0000\u0762"; | |
| private static final String _serializedATNSegment1 = | |
| "\u0761\u0001\u0000\u0000\u0000\u0763\u0766\u0001\u0000\u0000\u0000\u0764"+ | |
| "\u0762\u0001\u0000\u0000\u0000\u0764\u0765\u0001\u0000\u0000\u0000\u0765"+ | |
| "\u0769\u0001\u0000\u0000\u0000\u0766\u0764\u0001\u0000\u0000\u0000\u0767"+ | |
| "\u0768\u0007\u0005\u0000\u0000\u0768\u076a\u0005)\u0000\u0000\u0769\u0767"+ | |
| "\u0001\u0000\u0000\u0000\u0769\u076a\u0001\u0000\u0000\u0000\u076a\u076e"+ | |
| "\u0001\u0000\u0000\u0000\u076b\u076d\u0007\u0005\u0000\u0000\u076c\u076b"+ | |
| "\u0001\u0000\u0000\u0000\u076d\u0770\u0001\u0000\u0000\u0000\u076e\u076c"+ | |
| "\u0001\u0000\u0000\u0000\u076e\u076f\u0001\u0000\u0000\u0000\u076f\u0773"+ | |
| "\u0001\u0000\u0000\u0000\u0770\u076e\u0001\u0000\u0000\u0000\u0771\u0772"+ | |
| "\u0007\u0005\u0000\u0000\u0772\u0774\u0003\u0088D\u0000\u0773\u0771\u0001"+ | |
| "\u0000\u0000\u0000\u0773\u0774\u0001\u0000\u0000\u0000\u0774\u07a3\u0001"+ | |
| "\u0000\u0000\u0000\u0775\u0777\u0005\u0010\u0000\u0000\u0776\u0778\u0007"+ | |
| "\u0005\u0000\u0000\u0777\u0776\u0001\u0000\u0000\u0000\u0778\u0779\u0001"+ | |
| "\u0000\u0000\u0000\u0779\u0777\u0001\u0000\u0000\u0000\u0779\u077a\u0001"+ | |
| "\u0000\u0000\u0000\u077a\u077b\u0001\u0000\u0000\u0000\u077b\u07a3\u0003"+ | |
| "\u0088D\u0000\u077c\u0781\u0005\u0011\u0000\u0000\u077d\u0782\u0005\u0004"+ | |
| "\u0000\u0000\u077e\u0782\u0005\u0006\u0000\u0000\u077f\u0780\u0004G\u0016"+ | |
| "\u0000\u0780\u0782\u0005\u0001\u0000\u0000\u0781\u077d\u0001\u0000\u0000"+ | |
| "\u0000\u0781\u077e\u0001\u0000\u0000\u0000\u0781\u077f\u0001\u0000\u0000"+ | |
| "\u0000\u0782\u0783\u0001\u0000\u0000\u0000\u0783\u0781\u0001\u0000\u0000"+ | |
| "\u0000\u0783\u0784\u0001\u0000\u0000\u0000\u0784\u0785\u0001\u0000\u0000"+ | |
| "\u0000\u0785\u0789\u0005+\u0000\u0000\u0786\u0788\u0007\u0005\u0000\u0000"+ | |
| "\u0787\u0786\u0001\u0000\u0000\u0000\u0788\u078b\u0001\u0000\u0000\u0000"+ | |
| "\u0789\u0787\u0001\u0000\u0000\u0000\u0789\u078a\u0001\u0000\u0000\u0000"+ | |
| "\u078a\u078e\u0001\u0000\u0000\u0000\u078b\u0789\u0001\u0000\u0000\u0000"+ | |
| "\u078c\u078d\u0007\u0005\u0000\u0000\u078d\u078f\u0003\u0088D\u0000\u078e"+ | |
| "\u078c\u0001\u0000\u0000\u0000\u078e\u078f\u0001\u0000\u0000\u0000\u078f"+ | |
| "\u07a3\u0001\u0000\u0000\u0000\u0790\u0792\u0005\u0012\u0000\u0000\u0791"+ | |
| "\u0793\u0007\u0005\u0000\u0000\u0792\u0791\u0001\u0000\u0000\u0000\u0793"+ | |
| "\u0794\u0001\u0000\u0000\u0000\u0794\u0792\u0001\u0000\u0000\u0000\u0794"+ | |
| "\u0795\u0001\u0000\u0000\u0000\u0795\u0796\u0001\u0000\u0000\u0000\u0796"+ | |
| "\u07a3\u0003\u0088D\u0000\u0797\u079b\u0005\u0015\u0000\u0000\u0798\u079a"+ | |
| "\u0007\u0005\u0000\u0000\u0799\u0798\u0001\u0000\u0000\u0000\u079a\u079d"+ | |
| "\u0001\u0000\u0000\u0000\u079b\u0799\u0001\u0000\u0000\u0000\u079b\u079c"+ | |
| "\u0001\u0000\u0000\u0000\u079c\u07a0\u0001\u0000\u0000\u0000\u079d\u079b"+ | |
| "\u0001\u0000\u0000\u0000\u079e\u079f\u0007\u0005\u0000\u0000\u079f\u07a1"+ | |
| "\u0003\u0088D\u0000\u07a0\u079e\u0001\u0000\u0000\u0000\u07a0\u07a1\u0001"+ | |
| "\u0000\u0000\u0000\u07a1\u07a3\u0001\u0000\u0000\u0000\u07a2\u06df\u0001"+ | |
| "\u0000\u0000\u0000\u07a2\u06e6\u0001\u0000\u0000\u0000\u07a2\u06f1\u0001"+ | |
| "\u0000\u0000\u0000\u07a2\u0705\u0001\u0000\u0000\u0000\u07a2\u0719\u0001"+ | |
| "\u0000\u0000\u0000\u07a2\u0720\u0001\u0000\u0000\u0000\u07a2\u0738\u0001"+ | |
| "\u0000\u0000\u0000\u07a2\u074b\u0001\u0000\u0000\u0000\u07a2\u0756\u0001"+ | |
| "\u0000\u0000\u0000\u07a2\u0775\u0001\u0000\u0000\u0000\u07a2\u077c\u0001"+ | |
| "\u0000\u0000\u0000\u07a2\u0790\u0001\u0000\u0000\u0000\u07a2\u0797\u0001"+ | |
| "\u0000\u0000\u0000\u07a3\u008f\u0001\u0000\u0000\u0000\u07a4\u07ff\u0005"+ | |
| "\u0013\u0000\u0000\u07a5\u07ac\u0005-\u0000\u0000\u07a6\u07ab\u0005\u0004"+ | |
| "\u0000\u0000\u07a7\u07ab\u0005\u0006\u0000\u0000\u07a8\u07ab\u0005\u0001"+ | |
| "\u0000\u0000\u07a9\u07ab\u0003\u0094J\u0000\u07aa\u07a6\u0001\u0000\u0000"+ | |
| "\u0000\u07aa\u07a7\u0001\u0000\u0000\u0000\u07aa\u07a8\u0001\u0000\u0000"+ | |
| "\u0000\u07aa\u07a9\u0001\u0000\u0000\u0000\u07ab\u07ae\u0001\u0000\u0000"+ | |
| "\u0000\u07ac\u07aa\u0001\u0000\u0000\u0000\u07ac\u07ad\u0001\u0000\u0000"+ | |
| "\u0000\u07ad\u0800\u0001\u0000\u0000\u0000\u07ae\u07ac\u0001\u0000\u0000"+ | |
| "\u0000\u07af\u07b3\u0005.\u0000\u0000\u07b0\u07b2\u0007\u0000\u0000\u0000"+ | |
| "\u07b1\u07b0\u0001\u0000\u0000\u0000\u07b2\u07b5\u0001\u0000\u0000\u0000"+ | |
| "\u07b3\u07b1\u0001\u0000\u0000\u0000\u07b3\u07b4\u0001\u0000\u0000\u0000"+ | |
| "\u07b4\u0800\u0001\u0000\u0000\u0000\u07b5\u07b3\u0001\u0000\u0000\u0000"+ | |
| "\u07b6\u07ba\u0005/\u0000\u0000\u07b7\u07b9\u0007\u0000\u0000\u0000\u07b8"+ | |
| "\u07b7\u0001\u0000\u0000\u0000\u07b9\u07bc\u0001\u0000\u0000\u0000\u07ba"+ | |
| "\u07b8\u0001\u0000\u0000\u0000\u07ba\u07bb\u0001\u0000\u0000\u0000\u07bb"+ | |
| "\u0800\u0001\u0000\u0000\u0000\u07bc\u07ba\u0001\u0000\u0000\u0000\u07bd"+ | |
| "\u07bf\u00050\u0000\u0000\u07be\u07c0\u0007\u0000\u0000\u0000\u07bf\u07be"+ | |
| "\u0001\u0000\u0000\u0000\u07c0\u07c1\u0001\u0000\u0000\u0000\u07c1\u07bf"+ | |
| "\u0001\u0000\u0000\u0000\u07c1\u07c2\u0001\u0000\u0000\u0000\u07c2\u07c3"+ | |
| "\u0001\u0000\u0000\u0000\u07c3\u07c7\u0003\u008aE\u0000\u07c4\u07c6\u0007"+ | |
| "\u0005\u0000\u0000\u07c5\u07c4\u0001\u0000\u0000\u0000\u07c6\u07c9\u0001"+ | |
| "\u0000\u0000\u0000\u07c7\u07c5\u0001\u0000\u0000\u0000\u07c7\u07c8\u0001"+ | |
| "\u0000\u0000\u0000\u07c8\u07cc\u0001\u0000\u0000\u0000\u07c9\u07c7\u0001"+ | |
| "\u0000\u0000\u0000\u07ca\u07cb\u0007\u0005\u0000\u0000\u07cb\u07cd\u0003"+ | |
| "\u0088D\u0000\u07cc\u07ca\u0001\u0000\u0000\u0000\u07cc\u07cd\u0001\u0000"+ | |
| "\u0000\u0000\u07cd\u0800\u0001\u0000\u0000\u0000\u07ce\u07d0\u00051\u0000"+ | |
| "\u0000\u07cf\u07d1\u0007\u0000\u0000\u0000\u07d0\u07cf\u0001\u0000\u0000"+ | |
| "\u0000\u07d1\u07d2\u0001\u0000\u0000\u0000\u07d2\u07d0\u0001\u0000\u0000"+ | |
| "\u0000\u07d2\u07d3\u0001\u0000\u0000\u0000\u07d3\u07d4\u0001\u0000\u0000"+ | |
| "\u0000\u07d4\u07d8\u0003\u008aE\u0000\u07d5\u07d7\u0007\u0005\u0000\u0000"+ | |
| "\u07d6\u07d5\u0001\u0000\u0000\u0000\u07d7\u07da\u0001\u0000\u0000\u0000"+ | |
| "\u07d8\u07d6\u0001\u0000\u0000\u0000\u07d8\u07d9\u0001\u0000\u0000\u0000"+ | |
| "\u07d9\u07dd\u0001\u0000\u0000\u0000\u07da\u07d8\u0001\u0000\u0000\u0000"+ | |
| "\u07db\u07dc\u0007\u0005\u0000\u0000\u07dc\u07de\u0003\u0088D\u0000\u07dd"+ | |
| "\u07db\u0001\u0000\u0000\u0000\u07dd\u07de\u0001\u0000\u0000\u0000\u07de"+ | |
| "\u0800\u0001\u0000\u0000\u0000\u07df\u07e6\u00052\u0000\u0000\u07e0\u07e5"+ | |
| "\u0005\u0004\u0000\u0000\u07e1\u07e5\u0005\u0006\u0000\u0000\u07e2\u07e5"+ | |
| "\u0005\u0001\u0000\u0000\u07e3\u07e5\u0003\u0094J\u0000\u07e4\u07e0\u0001"+ | |
| "\u0000\u0000\u0000\u07e4\u07e1\u0001\u0000\u0000\u0000\u07e4\u07e2\u0001"+ | |
| "\u0000\u0000\u0000\u07e4\u07e3\u0001\u0000\u0000\u0000\u07e5\u07e8\u0001"+ | |
| "\u0000\u0000\u0000\u07e6\u07e4\u0001\u0000\u0000\u0000\u07e6\u07e7\u0001"+ | |
| "\u0000\u0000\u0000\u07e7\u0800\u0001\u0000\u0000\u0000\u07e8\u07e6\u0001"+ | |
| "\u0000\u0000\u0000\u07e9\u07ed\u00053\u0000\u0000\u07ea\u07ec\u0007\u0000"+ | |
| "\u0000\u0000\u07eb\u07ea\u0001\u0000\u0000\u0000\u07ec\u07ef\u0001\u0000"+ | |
| "\u0000\u0000\u07ed\u07eb\u0001\u0000\u0000\u0000\u07ed\u07ee\u0001\u0000"+ | |
| "\u0000\u0000\u07ee\u07f2\u0001\u0000\u0000\u0000\u07ef\u07ed\u0001\u0000"+ | |
| "\u0000\u0000\u07f0\u07f1\u0007\u0005\u0000\u0000\u07f1\u07f3\u0003\u008a"+ | |
| "E\u0000\u07f2\u07f0\u0001\u0000\u0000\u0000\u07f2\u07f3\u0001\u0000\u0000"+ | |
| "\u0000\u07f3\u0800\u0001\u0000\u0000\u0000\u07f4\u07f8\u0005\u0015\u0000"+ | |
| "\u0000\u07f5\u07f7\u0007\u0000\u0000\u0000\u07f6\u07f5\u0001\u0000\u0000"+ | |
| "\u0000\u07f7\u07fa\u0001\u0000\u0000\u0000\u07f8\u07f6\u0001\u0000\u0000"+ | |
| "\u0000\u07f8\u07f9\u0001\u0000\u0000\u0000\u07f9\u07fd\u0001\u0000\u0000"+ | |
| "\u0000\u07fa\u07f8\u0001\u0000\u0000\u0000\u07fb\u07fc\u0007\u0005\u0000"+ | |
| "\u0000\u07fc\u07fe\u0003\u0088D\u0000\u07fd\u07fb\u0001\u0000\u0000\u0000"+ | |
| "\u07fd\u07fe\u0001\u0000\u0000\u0000\u07fe\u0800\u0001\u0000\u0000\u0000"+ | |
| "\u07ff\u07a5\u0001\u0000\u0000\u0000\u07ff\u07af\u0001\u0000\u0000\u0000"+ | |
| "\u07ff\u07b6\u0001\u0000\u0000\u0000\u07ff\u07bd\u0001\u0000\u0000\u0000"+ | |
| "\u07ff\u07ce\u0001\u0000\u0000\u0000\u07ff\u07df\u0001\u0000\u0000\u0000"+ | |
| "\u07ff\u07e9\u0001\u0000\u0000\u0000\u07ff\u07f4\u0001\u0000\u0000\u0000"+ | |
| "\u0800\u0801\u0001\u0000\u0000\u0000\u0801\u0802\u0005\u0014\u0000\u0000"+ | |
| "\u0802\u0091\u0001\u0000\u0000\u0000\u0803\u0809\u0005\u0002\u0000\u0000"+ | |
| "\u0804\u0808\u0003\u0094J\u0000\u0805\u0808\u0005\u0006\u0000\u0000\u0806"+ | |
| "\u0808\u0005\u0001\u0000\u0000\u0807\u0804\u0001\u0000\u0000\u0000\u0807"+ | |
| "\u0805\u0001\u0000\u0000\u0000\u0807\u0806\u0001\u0000\u0000\u0000\u0808"+ | |
| "\u080b\u0001\u0000\u0000\u0000\u0809\u0807\u0001\u0000\u0000\u0000\u0809"+ | |
| "\u080a\u0001\u0000\u0000\u0000\u080a\u080c\u0001\u0000\u0000\u0000\u080b"+ | |
| "\u0809\u0001\u0000\u0000\u0000\u080c\u080d\u0005[\u0000\u0000\u080d\u0093"+ | |
| "\u0001\u0000\u0000\u0000\u080e\u080f\u0007\u0006\u0000\u0000\u080f\u0811"+ | |
| "\u0006J\uffff\uffff\u0000\u0810\u080e\u0001\u0000\u0000\u0000\u0811\u0812"+ | |
| "\u0001\u0000\u0000\u0000\u0812\u0810\u0001\u0000\u0000\u0000\u0812\u0813"+ | |
| "\u0001\u0000\u0000\u0000\u0813\u0095\u0001\u0000\u0000\u0000\u0814\u0815"+ | |
| "\u0005\u0005\u0000\u0000\u0815\u081c\u0005W\u0000\u0000\u0816\u081b\u0003"+ | |
| "\b\u0004\u0000\u0817\u081b\u0005\u0006\u0000\u0000\u0818\u081b\u0005\u0001"+ | |
| "\u0000\u0000\u0819\u081b\u0005\u0004\u0000\u0000\u081a\u0816\u0001\u0000"+ | |
| "\u0000\u0000\u081a\u0817\u0001\u0000\u0000\u0000\u081a\u0818\u0001\u0000"+ | |
| "\u0000\u0000\u081a\u0819\u0001\u0000\u0000\u0000\u081b\u081e\u0001\u0000"+ | |
| "\u0000\u0000\u081c\u081a\u0001\u0000\u0000\u0000\u081c\u081d\u0001\u0000"+ | |
| "\u0000\u0000\u081d\u081f\u0001\u0000\u0000\u0000\u081e\u081c\u0001\u0000"+ | |
| "\u0000\u0000\u081f\u0820\u0007\u0002\u0000\u0000\u0820\u0097\u0001\u0000"+ | |
| "\u0000\u0000\u0821\u0822\u0005\u0005\u0000\u0000\u0822\u0829\u0005X\u0000"+ | |
| "\u0000\u0823\u0828\u0003\b\u0004\u0000\u0824\u0828\u0005\u0006\u0000\u0000"+ | |
| "\u0825\u0828\u0005\u0001\u0000\u0000\u0826\u0828\u0005\u0004\u0000\u0000"+ | |
| "\u0827\u0823\u0001\u0000\u0000\u0000\u0827\u0824\u0001\u0000\u0000\u0000"+ | |
| "\u0827\u0825\u0001\u0000\u0000\u0000\u0827\u0826\u0001\u0000\u0000\u0000"+ | |
| "\u0828\u082b\u0001\u0000\u0000\u0000\u0829\u0827\u0001\u0000\u0000\u0000"+ | |
| "\u0829\u082a\u0001\u0000\u0000\u0000\u082a\u082c\u0001\u0000\u0000\u0000"+ | |
| "\u082b\u0829\u0001\u0000\u0000\u0000\u082c\u082d\u0007\u0002\u0000\u0000"+ | |
| "\u082d\u0099\u0001\u0000\u0000\u0000\u082e\u082f\u0005\u0005\u0000\u0000"+ | |
| "\u082f\u0836\u0005\\\u0000\u0000\u0830\u0835\u0003\b\u0004\u0000\u0831"+ | |
| "\u0835\u0005\u0006\u0000\u0000\u0832\u0835\u0005\u0001\u0000\u0000\u0833"+ | |
| "\u0835\u0005\u0004\u0000\u0000\u0834\u0830\u0001\u0000\u0000\u0000\u0834"+ | |
| "\u0831\u0001\u0000\u0000\u0000\u0834\u0832\u0001\u0000\u0000\u0000\u0834"+ | |
| "\u0833\u0001\u0000\u0000\u0000\u0835\u0838\u0001\u0000\u0000\u0000\u0836"+ | |
| "\u0834\u0001\u0000\u0000\u0000\u0836\u0837\u0001\u0000\u0000\u0000\u0837"+ | |
| "\u0839\u0001\u0000\u0000\u0000\u0838\u0836\u0001\u0000\u0000\u0000\u0839"+ | |
| "\u083a\u0007\u0002\u0000\u0000\u083a\u009b\u0001\u0000\u0000\u0000\u083b"+ | |
| "\u083c\u0005\u0005\u0000\u0000\u083c\u0843\u0005]\u0000\u0000\u083d\u0842"+ | |
| "\u0003\b\u0004\u0000\u083e\u0842\u0005\u0006\u0000\u0000\u083f\u0842\u0005"+ | |
| "\u0001\u0000\u0000\u0840\u0842\u0005\u0004\u0000\u0000\u0841\u083d\u0001"+ | |
| "\u0000\u0000\u0000\u0841\u083e\u0001\u0000\u0000\u0000\u0841\u083f\u0001"+ | |
| "\u0000\u0000\u0000\u0841\u0840\u0001\u0000\u0000\u0000\u0842\u0845\u0001"+ | |
| "\u0000\u0000\u0000\u0843\u0841\u0001\u0000\u0000\u0000\u0843\u0844\u0001"+ | |
| "\u0000\u0000\u0000\u0844\u0846\u0001\u0000\u0000\u0000\u0845\u0843\u0001"+ | |
| "\u0000\u0000\u0000\u0846\u0847\u0007\u0002\u0000\u0000\u0847\u009d\u0001"+ | |
| "\u0000\u0000\u0000\u0848\u0849\u0005\u0005\u0000\u0000\u0849\u0850\u0005"+ | |
| "^\u0000\u0000\u084a\u084f\u0003\b\u0004\u0000\u084b\u084f\u0005\u0006"+ | |
| "\u0000\u0000\u084c\u084f\u0005\u0001\u0000\u0000\u084d\u084f\u0005\u0004"+ | |
| "\u0000\u0000\u084e\u084a\u0001\u0000\u0000\u0000\u084e\u084b\u0001\u0000"+ | |
| "\u0000\u0000\u084e\u084c\u0001\u0000\u0000\u0000\u084e\u084d\u0001\u0000"+ | |
| "\u0000\u0000\u084f\u0852\u0001\u0000\u0000\u0000\u0850\u084e\u0001\u0000"+ | |
| "\u0000\u0000\u0850\u0851\u0001\u0000\u0000\u0000\u0851\u0853\u0001\u0000"+ | |
| "\u0000\u0000\u0852\u0850\u0001\u0000\u0000\u0000\u0853\u0854\u0007\u0002"+ | |
| "\u0000\u0000\u0854\u009f\u0001\u0000\u0000\u0000\u0855\u0856\u0005\u0005"+ | |
| "\u0000\u0000\u0856\u085d\u0005_\u0000\u0000\u0857\u085c\u0003\b\u0004"+ | |
| "\u0000\u0858\u085c\u0005\u0006\u0000\u0000\u0859\u085c\u0005\u0001\u0000"+ | |
| "\u0000\u085a\u085c\u0005\u0004\u0000\u0000\u085b\u0857\u0001\u0000\u0000"+ | |
| "\u0000\u085b\u0858\u0001\u0000\u0000\u0000\u085b\u0859\u0001\u0000\u0000"+ | |
| "\u0000\u085b\u085a\u0001\u0000\u0000\u0000\u085c\u085f\u0001\u0000\u0000"+ | |
| "\u0000\u085d\u085b\u0001\u0000\u0000\u0000\u085d\u085e\u0001\u0000\u0000"+ | |
| "\u0000\u085e\u0860\u0001\u0000\u0000\u0000\u085f\u085d\u0001\u0000\u0000"+ | |
| "\u0000\u0860\u0861\u00057\u0000\u0000\u0861\u00a1\u0001\u0000\u0000\u0000"+ | |
| "\u0862\u0863\u0005\u0005\u0000\u0000\u0863\u0864\u00059\u0000\u0000\u0864"+ | |
| "\u0868\u0005_\u0000\u0000\u0865\u0867\u0007\u0000\u0000\u0000\u0866\u0865"+ | |
| "\u0001\u0000\u0000\u0000\u0867\u086a\u0001\u0000\u0000\u0000\u0868\u0866"+ | |
| "\u0001\u0000\u0000\u0000\u0868\u0869\u0001\u0000\u0000\u0000\u0869\u086b"+ | |
| "\u0001\u0000\u0000\u0000\u086a\u0868\u0001\u0000\u0000\u0000\u086b\u086c"+ | |
| "\u00057\u0000\u0000\u086c\u00a3\u0001\u0000\u0000\u0000\u086d\u0894\u0003"+ | |
| "\u00a0P\u0000\u086e\u0893\u0003\n\u0005\u0000\u086f\u0893\u0003f3\u0000"+ | |
| "\u0870\u0893\u0003\u0010\b\u0000\u0871\u0893\u0003\u0016\u000b\u0000\u0872"+ | |
| "\u0893\u0003\u001c\u000e\u0000\u0873\u0893\u0003\"\u0011\u0000\u0874\u0893"+ | |
| "\u0003(\u0014\u0000\u0875\u0893\u0003.\u0017\u0000\u0876\u0893\u00034"+ | |
| "\u001a\u0000\u0877\u0893\u0003:\u001d\u0000\u0878\u0893\u0003@ \u0000"+ | |
| "\u0879\u0893\u0003F#\u0000\u087a\u0893\u0003L&\u0000\u087b\u0893\u0003"+ | |
| "R)\u0000\u087c\u0893\u0003X,\u0000\u087d\u0893\u0003^/\u0000\u087e\u0893"+ | |
| "\u0003\f\u0006\u0000\u087f\u0893\u0003\u0012\t\u0000\u0880\u0893\u0003"+ | |
| "\u0018\f\u0000\u0881\u0893\u0003\u001e\u000f\u0000\u0882\u0893\u0003$"+ | |
| "\u0012\u0000\u0883\u0893\u0003*\u0015\u0000\u0884\u0893\u00030\u0018\u0000"+ | |
| "\u0885\u0893\u00036\u001b\u0000\u0886\u0893\u0003<\u001e\u0000\u0887\u0893"+ | |
| "\u0003B!\u0000\u0888\u0893\u0003H$\u0000\u0889\u0893\u0003N\'\u0000\u088a"+ | |
| "\u0893\u0003T*\u0000\u088b\u0893\u0003Z-\u0000\u088c\u088d\u0004R\u0017"+ | |
| "\u0000\u088d\u0893\u0005\u0001\u0000\u0000\u088e\u0893\u0003\u0092I\u0000"+ | |
| "\u088f\u0893\u0005\u0006\u0000\u0000\u0890\u0893\u0003\u0094J\u0000\u0891"+ | |
| "\u0893\u0003\u0090H\u0000\u0892\u086e\u0001\u0000\u0000\u0000\u0892\u086f"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u0870\u0001\u0000\u0000\u0000\u0892\u0871"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u0872\u0001\u0000\u0000\u0000\u0892\u0873"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u0874\u0001\u0000\u0000\u0000\u0892\u0875"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u0876\u0001\u0000\u0000\u0000\u0892\u0877"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u0878\u0001\u0000\u0000\u0000\u0892\u0879"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u087a\u0001\u0000\u0000\u0000\u0892\u087b"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u087c\u0001\u0000\u0000\u0000\u0892\u087d"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u087e\u0001\u0000\u0000\u0000\u0892\u087f"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u0880\u0001\u0000\u0000\u0000\u0892\u0881"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u0882\u0001\u0000\u0000\u0000\u0892\u0883"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u0884\u0001\u0000\u0000\u0000\u0892\u0885"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u0886\u0001\u0000\u0000\u0000\u0892\u0887"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u0888\u0001\u0000\u0000\u0000\u0892\u0889"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u088a\u0001\u0000\u0000\u0000\u0892\u088b"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u088c\u0001\u0000\u0000\u0000\u0892\u088e"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u088f\u0001\u0000\u0000\u0000\u0892\u0890"+ | |
| "\u0001\u0000\u0000\u0000\u0892\u0891\u0001\u0000\u0000\u0000\u0893\u0896"+ | |
| "\u0001\u0000\u0000\u0000\u0894\u0892\u0001\u0000\u0000\u0000\u0894\u0895"+ | |
| "\u0001\u0000\u0000\u0000\u0895\u0897\u0001\u0000\u0000\u0000\u0896\u0894"+ | |
| "\u0001\u0000\u0000\u0000\u0897\u0898\u0003\u00a2Q\u0000\u0898\u00a5\u0001"+ | |
| "\u0000\u0000\u0000\u0899\u089a\u0005\u0005\u0000\u0000\u089a\u08a1\u0005"+ | |
| "`\u0000\u0000\u089b\u08a0\u0003\b\u0004\u0000\u089c\u08a0\u0005\u0006"+ | |
| "\u0000\u0000\u089d\u08a0\u0005\u0001\u0000\u0000\u089e\u08a0\u0005\u0004"+ | |
| "\u0000\u0000\u089f\u089b\u0001\u0000\u0000\u0000\u089f\u089c\u0001\u0000"+ | |
| "\u0000\u0000\u089f\u089d\u0001\u0000\u0000\u0000\u089f\u089e\u0001\u0000"+ | |
| "\u0000\u0000\u08a0\u08a3\u0001\u0000\u0000\u0000\u08a1\u089f\u0001\u0000"+ | |
| "\u0000\u0000\u08a1\u08a2\u0001\u0000\u0000\u0000\u08a2\u08a4\u0001\u0000"+ | |
| "\u0000\u0000\u08a3\u08a1\u0001\u0000\u0000\u0000\u08a4\u08a5\u00057\u0000"+ | |
| "\u0000\u08a5\u00a7\u0001\u0000\u0000\u0000\u08a6\u08a7\u0005\u0005\u0000"+ | |
| "\u0000\u08a7\u08a8\u00059\u0000\u0000\u08a8\u08ac\u0005`\u0000\u0000\u08a9"+ | |
| "\u08ab\u0007\u0000\u0000\u0000\u08aa\u08a9\u0001\u0000\u0000\u0000\u08ab"+ | |
| "\u08ae\u0001\u0000\u0000\u0000\u08ac\u08aa\u0001\u0000\u0000\u0000\u08ac"+ | |
| "\u08ad\u0001\u0000\u0000\u0000\u08ad\u08af\u0001\u0000\u0000\u0000\u08ae"+ | |
| "\u08ac\u0001\u0000\u0000\u0000\u08af\u08b0\u00057\u0000\u0000\u08b0\u00a9"+ | |
| "\u0001\u0000\u0000\u0000\u08b1\u08d8\u0003\u00a6S\u0000\u08b2\u08d7\u0003"+ | |
| "\n\u0005\u0000\u08b3\u08d7\u0003f3\u0000\u08b4\u08d7\u0003\u0010\b\u0000"+ | |
| "\u08b5\u08d7\u0003\u0016\u000b\u0000\u08b6\u08d7\u0003\u001c\u000e\u0000"+ | |
| "\u08b7\u08d7\u0003\"\u0011\u0000\u08b8\u08d7\u0003(\u0014\u0000\u08b9"+ | |
| "\u08d7\u0003.\u0017\u0000\u08ba\u08d7\u00034\u001a\u0000\u08bb\u08d7\u0003"+ | |
| ":\u001d\u0000\u08bc\u08d7\u0003@ \u0000\u08bd\u08d7\u0003F#\u0000\u08be"+ | |
| "\u08d7\u0003L&\u0000\u08bf\u08d7\u0003R)\u0000\u08c0\u08d7\u0003X,\u0000"+ | |
| "\u08c1\u08d7\u0003^/\u0000\u08c2\u08d7\u0003\f\u0006\u0000\u08c3\u08d7"+ | |
| "\u0003\u0012\t\u0000\u08c4\u08d7\u0003\u0018\f\u0000\u08c5\u08d7\u0003"+ | |
| "\u001e\u000f\u0000\u08c6\u08d7\u0003$\u0012\u0000\u08c7\u08d7\u0003*\u0015"+ | |
| "\u0000\u08c8\u08d7\u00030\u0018\u0000\u08c9\u08d7\u00036\u001b\u0000\u08ca"+ | |
| "\u08d7\u0003<\u001e\u0000\u08cb\u08d7\u0003B!\u0000\u08cc\u08d7\u0003"+ | |
| "H$\u0000\u08cd\u08d7\u0003N\'\u0000\u08ce\u08d7\u0003T*\u0000\u08cf\u08d7"+ | |
| "\u0003Z-\u0000\u08d0\u08d1\u0004U\u0018\u0000\u08d1\u08d7\u0005\u0001"+ | |
| "\u0000\u0000\u08d2\u08d7\u0003\u0092I\u0000\u08d3\u08d7\u0005\u0006\u0000"+ | |
| "\u0000\u08d4\u08d7\u0003\u0094J\u0000\u08d5\u08d7\u0003\u0090H\u0000\u08d6"+ | |
| "\u08b2\u0001\u0000\u0000\u0000\u08d6\u08b3\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08b4\u0001\u0000\u0000\u0000\u08d6\u08b5\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08b6\u0001\u0000\u0000\u0000\u08d6\u08b7\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08b8\u0001\u0000\u0000\u0000\u08d6\u08b9\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08ba\u0001\u0000\u0000\u0000\u08d6\u08bb\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08bc\u0001\u0000\u0000\u0000\u08d6\u08bd\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08be\u0001\u0000\u0000\u0000\u08d6\u08bf\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08c0\u0001\u0000\u0000\u0000\u08d6\u08c1\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08c2\u0001\u0000\u0000\u0000\u08d6\u08c3\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08c4\u0001\u0000\u0000\u0000\u08d6\u08c5\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08c6\u0001\u0000\u0000\u0000\u08d6\u08c7\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08c8\u0001\u0000\u0000\u0000\u08d6\u08c9\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08ca\u0001\u0000\u0000\u0000\u08d6\u08cb\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08cc\u0001\u0000\u0000\u0000\u08d6\u08cd\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08ce\u0001\u0000\u0000\u0000\u08d6\u08cf\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08d0\u0001\u0000\u0000\u0000\u08d6\u08d2\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08d3\u0001\u0000\u0000\u0000\u08d6\u08d4\u0001\u0000\u0000\u0000\u08d6"+ | |
| "\u08d5\u0001\u0000\u0000\u0000\u08d7\u08da\u0001\u0000\u0000\u0000\u08d8"+ | |
| "\u08d6\u0001\u0000\u0000\u0000\u08d8\u08d9\u0001\u0000\u0000\u0000\u08d9"+ | |
| "\u08db\u0001\u0000\u0000\u0000\u08da\u08d8\u0001\u0000\u0000\u0000\u08db"+ | |
| "\u08dc\u0003\u00a8T\u0000\u08dc\u00ab\u0001\u0000\u0000\u0000\u08dd\u08de"+ | |
| "\u0005\u0005\u0000\u0000\u08de\u08e5\u0005a\u0000\u0000\u08df\u08e4\u0003"+ | |
| "\b\u0004\u0000\u08e0\u08e4\u0005\u0006\u0000\u0000\u08e1\u08e4\u0005\u0001"+ | |
| "\u0000\u0000\u08e2\u08e4\u0005\u0004\u0000\u0000\u08e3\u08df\u0001\u0000"+ | |
| "\u0000\u0000\u08e3\u08e0\u0001\u0000\u0000\u0000\u08e3\u08e1\u0001\u0000"+ | |
| "\u0000\u0000\u08e3\u08e2\u0001\u0000\u0000\u0000\u08e4\u08e7\u0001\u0000"+ | |
| "\u0000\u0000\u08e5\u08e3\u0001\u0000\u0000\u0000\u08e5\u08e6\u0001\u0000"+ | |
| "\u0000\u0000\u08e6\u08e8\u0001\u0000\u0000\u0000\u08e7\u08e5\u0001\u0000"+ | |
| "\u0000\u0000\u08e8\u08e9\u00057\u0000\u0000\u08e9\u00ad\u0001\u0000\u0000"+ | |
| "\u0000\u08ea\u08eb\u0005\u0005\u0000\u0000\u08eb\u08ec\u00059\u0000\u0000"+ | |
| "\u08ec\u08f0\u0005a\u0000\u0000\u08ed\u08ef\u0007\u0000\u0000\u0000\u08ee"+ | |
| "\u08ed\u0001\u0000\u0000\u0000\u08ef\u08f2\u0001\u0000\u0000\u0000\u08f0"+ | |
| "\u08ee\u0001\u0000\u0000\u0000\u08f0\u08f1\u0001\u0000\u0000\u0000\u08f1"+ | |
| "\u08f3\u0001\u0000\u0000\u0000\u08f2\u08f0\u0001\u0000\u0000\u0000\u08f3"+ | |
| "\u08f4\u00057\u0000\u0000\u08f4\u00af\u0001\u0000\u0000\u0000\u08f5\u091c"+ | |
| "\u0003\u00acV\u0000\u08f6\u091b\u0003\n\u0005\u0000\u08f7\u091b\u0003"+ | |
| "f3\u0000\u08f8\u091b\u0003\u0010\b\u0000\u08f9\u091b\u0003\u0016\u000b"+ | |
| "\u0000\u08fa\u091b\u0003\u001c\u000e\u0000\u08fb\u091b\u0003\"\u0011\u0000"+ | |
| "\u08fc\u091b\u0003(\u0014\u0000\u08fd\u091b\u0003.\u0017\u0000\u08fe\u091b"+ | |
| "\u00034\u001a\u0000\u08ff\u091b\u0003:\u001d\u0000\u0900\u091b\u0003@"+ | |
| " \u0000\u0901\u091b\u0003F#\u0000\u0902\u091b\u0003L&\u0000\u0903\u091b"+ | |
| "\u0003R)\u0000\u0904\u091b\u0003X,\u0000\u0905\u091b\u0003^/\u0000\u0906"+ | |
| "\u091b\u0003\f\u0006\u0000\u0907\u091b\u0003\u0012\t\u0000\u0908\u091b"+ | |
| "\u0003\u0018\f\u0000\u0909\u091b\u0003\u001e\u000f\u0000\u090a\u091b\u0003"+ | |
| "$\u0012\u0000\u090b\u091b\u0003*\u0015\u0000\u090c\u091b\u00030\u0018"+ | |
| "\u0000\u090d\u091b\u00036\u001b\u0000\u090e\u091b\u0003<\u001e\u0000\u090f"+ | |
| "\u091b\u0003B!\u0000\u0910\u091b\u0003H$\u0000\u0911\u091b\u0003N\'\u0000"+ | |
| "\u0912\u091b\u0003T*\u0000\u0913\u091b\u0003Z-\u0000\u0914\u0915\u0004"+ | |
| "X\u0019\u0000\u0915\u091b\u0005\u0001\u0000\u0000\u0916\u091b\u0003\u0092"+ | |
| "I\u0000\u0917\u091b\u0005\u0006\u0000\u0000\u0918\u091b\u0003\u0094J\u0000"+ | |
| "\u0919\u091b\u0003\u0090H\u0000\u091a\u08f6\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u08f7\u0001\u0000\u0000\u0000\u091a\u08f8\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u08f9\u0001\u0000\u0000\u0000\u091a\u08fa\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u08fb\u0001\u0000\u0000\u0000\u091a\u08fc\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u08fd\u0001\u0000\u0000\u0000\u091a\u08fe\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u08ff\u0001\u0000\u0000\u0000\u091a\u0900\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u0901\u0001\u0000\u0000\u0000\u091a\u0902\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u0903\u0001\u0000\u0000\u0000\u091a\u0904\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u0905\u0001\u0000\u0000\u0000\u091a\u0906\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u0907\u0001\u0000\u0000\u0000\u091a\u0908\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u0909\u0001\u0000\u0000\u0000\u091a\u090a\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u090b\u0001\u0000\u0000\u0000\u091a\u090c\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u090d\u0001\u0000\u0000\u0000\u091a\u090e\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u090f\u0001\u0000\u0000\u0000\u091a\u0910\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u0911\u0001\u0000\u0000\u0000\u091a\u0912\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u0913\u0001\u0000\u0000\u0000\u091a\u0914\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u0916\u0001\u0000\u0000\u0000\u091a\u0917\u0001\u0000\u0000\u0000\u091a"+ | |
| "\u0918\u0001\u0000\u0000\u0000\u091a\u0919\u0001\u0000\u0000\u0000\u091b"+ | |
| "\u091e\u0001\u0000\u0000\u0000\u091c\u091a\u0001\u0000\u0000\u0000\u091c"+ | |
| "\u091d\u0001\u0000\u0000\u0000\u091d\u091f\u0001\u0000\u0000\u0000\u091e"+ | |
| "\u091c\u0001\u0000\u0000\u0000\u091f\u0920\u0003\u00aeW\u0000\u0920\u00b1"+ | |
| "\u0001\u0000\u0000\u0000\u0921\u0922\u0005\u0005\u0000\u0000\u0922\u0929"+ | |
| "\u0005b\u0000\u0000\u0923\u0928\u0003\b\u0004\u0000\u0924\u0928\u0005"+ | |
| "\u0006\u0000\u0000\u0925\u0928\u0005\u0001\u0000\u0000\u0926\u0928\u0005"+ | |
| "\u0004\u0000\u0000\u0927\u0923\u0001\u0000\u0000\u0000\u0927\u0924\u0001"+ | |
| "\u0000\u0000\u0000\u0927\u0925\u0001\u0000\u0000\u0000\u0927\u0926\u0001"+ | |
| "\u0000\u0000\u0000\u0928\u092b\u0001\u0000\u0000\u0000\u0929\u0927\u0001"+ | |
| "\u0000\u0000\u0000\u0929\u092a\u0001\u0000\u0000\u0000\u092a\u092c\u0001"+ | |
| "\u0000\u0000\u0000\u092b\u0929\u0001\u0000\u0000\u0000\u092c\u092d\u0005"+ | |
| "7\u0000\u0000\u092d\u00b3\u0001\u0000\u0000\u0000\u092e\u092f\u0005\u0005"+ | |
| "\u0000\u0000\u092f\u0930\u00059\u0000\u0000\u0930\u0934\u0005b\u0000\u0000"+ | |
| "\u0931\u0933\u0007\u0000\u0000\u0000\u0932\u0931\u0001\u0000\u0000\u0000"+ | |
| "\u0933\u0936\u0001\u0000\u0000\u0000\u0934\u0932\u0001\u0000\u0000\u0000"+ | |
| "\u0934\u0935\u0001\u0000\u0000\u0000\u0935\u0937\u0001\u0000\u0000\u0000"+ | |
| "\u0936\u0934\u0001\u0000\u0000\u0000\u0937\u0938\u00057\u0000\u0000\u0938"+ | |
| "\u00b5\u0001\u0000\u0000\u0000\u0939\u0960\u0003\u00b2Y\u0000\u093a\u095f"+ | |
| "\u0003\n\u0005\u0000\u093b\u095f\u0003f3\u0000\u093c\u095f\u0003\u0010"+ | |
| "\b\u0000\u093d\u095f\u0003\u0016\u000b\u0000\u093e\u095f\u0003\u001c\u000e"+ | |
| "\u0000\u093f\u095f\u0003\"\u0011\u0000\u0940\u095f\u0003(\u0014\u0000"+ | |
| "\u0941\u095f\u0003.\u0017\u0000\u0942\u095f\u00034\u001a\u0000\u0943\u095f"+ | |
| "\u0003:\u001d\u0000\u0944\u095f\u0003@ \u0000\u0945\u095f\u0003F#\u0000"+ | |
| "\u0946\u095f\u0003L&\u0000\u0947\u095f\u0003R)\u0000\u0948\u095f\u0003"+ | |
| "X,\u0000\u0949\u095f\u0003^/\u0000\u094a\u095f\u0003\f\u0006\u0000\u094b"+ | |
| "\u095f\u0003\u0012\t\u0000\u094c\u095f\u0003\u0018\f\u0000\u094d\u095f"+ | |
| "\u0003\u001e\u000f\u0000\u094e\u095f\u0003$\u0012\u0000\u094f\u095f\u0003"+ | |
| "*\u0015\u0000\u0950\u095f\u00030\u0018\u0000\u0951\u095f\u00036\u001b"+ | |
| "\u0000\u0952\u095f\u0003<\u001e\u0000\u0953\u095f\u0003B!\u0000\u0954"+ | |
| "\u095f\u0003H$\u0000\u0955\u095f\u0003N\'\u0000\u0956\u095f\u0003T*\u0000"+ | |
| "\u0957\u095f\u0003Z-\u0000\u0958\u0959\u0004[\u001a\u0000\u0959\u095f"+ | |
| "\u0005\u0001\u0000\u0000\u095a\u095f\u0003\u0092I\u0000\u095b\u095f\u0005"+ | |
| "\u0006\u0000\u0000\u095c\u095f\u0003\u0094J\u0000\u095d\u095f\u0003\u0090"+ | |
| "H\u0000\u095e\u093a\u0001\u0000\u0000\u0000\u095e\u093b\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u093c\u0001\u0000\u0000\u0000\u095e\u093d\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u093e\u0001\u0000\u0000\u0000\u095e\u093f\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u0940\u0001\u0000\u0000\u0000\u095e\u0941\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u0942\u0001\u0000\u0000\u0000\u095e\u0943\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u0944\u0001\u0000\u0000\u0000\u095e\u0945\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u0946\u0001\u0000\u0000\u0000\u095e\u0947\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u0948\u0001\u0000\u0000\u0000\u095e\u0949\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u094a\u0001\u0000\u0000\u0000\u095e\u094b\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u094c\u0001\u0000\u0000\u0000\u095e\u094d\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u094e\u0001\u0000\u0000\u0000\u095e\u094f\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u0950\u0001\u0000\u0000\u0000\u095e\u0951\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u0952\u0001\u0000\u0000\u0000\u095e\u0953\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u0954\u0001\u0000\u0000\u0000\u095e\u0955\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u0956\u0001\u0000\u0000\u0000\u095e\u0957\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u0958\u0001\u0000\u0000\u0000\u095e\u095a\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u095b\u0001\u0000\u0000\u0000\u095e\u095c\u0001\u0000\u0000"+ | |
| "\u0000\u095e\u095d\u0001\u0000\u0000\u0000\u095f\u0962\u0001\u0000\u0000"+ | |
| "\u0000\u0960\u095e\u0001\u0000\u0000\u0000\u0960\u0961\u0001\u0000\u0000"+ | |
| "\u0000\u0961\u0963\u0001\u0000\u0000\u0000\u0962\u0960\u0001\u0000\u0000"+ | |
| "\u0000\u0963\u0964\u0003\u00b4Z\u0000\u0964\u00b7\u0001\u0000\u0000\u0000"+ | |
| "\u0965\u0966\u0005\u0005\u0000\u0000\u0966\u096d\u0005c\u0000\u0000\u0967"+ | |
| "\u096c\u0003\b\u0004\u0000\u0968\u096c\u0005\u0006\u0000\u0000\u0969\u096c"+ | |
| "\u0005\u0001\u0000\u0000\u096a\u096c\u0005\u0004\u0000\u0000\u096b\u0967"+ | |
| "\u0001\u0000\u0000\u0000\u096b\u0968\u0001\u0000\u0000\u0000\u096b\u0969"+ | |
| "\u0001\u0000\u0000\u0000\u096b\u096a\u0001\u0000\u0000\u0000\u096c\u096f"+ | |
| "\u0001\u0000\u0000\u0000\u096d\u096b\u0001\u0000\u0000\u0000\u096d\u096e"+ | |
| "\u0001\u0000\u0000\u0000\u096e\u0970\u0001\u0000\u0000\u0000\u096f\u096d"+ | |
| "\u0001\u0000\u0000\u0000\u0970\u0971\u00057\u0000\u0000\u0971\u00b9\u0001"+ | |
| "\u0000\u0000\u0000\u0972\u0973\u0005\u0005\u0000\u0000\u0973\u0974\u0005"+ | |
| "9\u0000\u0000\u0974\u0978\u0005c\u0000\u0000\u0975\u0977\u0007\u0000\u0000"+ | |
| "\u0000\u0976\u0975\u0001\u0000\u0000\u0000\u0977\u097a\u0001\u0000\u0000"+ | |
| "\u0000\u0978\u0976\u0001\u0000\u0000\u0000\u0978\u0979\u0001\u0000\u0000"+ | |
| "\u0000\u0979\u097b\u0001\u0000\u0000\u0000\u097a\u0978\u0001\u0000\u0000"+ | |
| "\u0000\u097b\u097c\u00057\u0000\u0000\u097c\u00bb\u0001\u0000\u0000\u0000"+ | |
| "\u097d\u09a4\u0003\u00b8\\\u0000\u097e\u09a3\u0003\n\u0005\u0000\u097f"+ | |
| "\u09a3\u0003f3\u0000\u0980\u09a3\u0003\u0010\b\u0000\u0981\u09a3\u0003"+ | |
| "\u0016\u000b\u0000\u0982\u09a3\u0003\u001c\u000e\u0000\u0983\u09a3\u0003"+ | |
| "\"\u0011\u0000\u0984\u09a3\u0003(\u0014\u0000\u0985\u09a3\u0003.\u0017"+ | |
| "\u0000\u0986\u09a3\u00034\u001a\u0000\u0987\u09a3\u0003:\u001d\u0000\u0988"+ | |
| "\u09a3\u0003@ \u0000\u0989\u09a3\u0003F#\u0000\u098a\u09a3\u0003L&\u0000"+ | |
| "\u098b\u09a3\u0003R)\u0000\u098c\u09a3\u0003X,\u0000\u098d\u09a3\u0003"+ | |
| "^/\u0000\u098e\u09a3\u0003\f\u0006\u0000\u098f\u09a3\u0003\u0012\t\u0000"+ | |
| "\u0990\u09a3\u0003\u0018\f\u0000\u0991\u09a3\u0003\u001e\u000f\u0000\u0992"+ | |
| "\u09a3\u0003$\u0012\u0000\u0993\u09a3\u0003*\u0015\u0000\u0994\u09a3\u0003"+ | |
| "0\u0018\u0000\u0995\u09a3\u00036\u001b\u0000\u0996\u09a3\u0003<\u001e"+ | |
| "\u0000\u0997\u09a3\u0003B!\u0000\u0998\u09a3\u0003H$\u0000\u0999\u09a3"+ | |
| "\u0003N\'\u0000\u099a\u09a3\u0003T*\u0000\u099b\u09a3\u0003Z-\u0000\u099c"+ | |
| "\u099d\u0004^\u001b\u0000\u099d\u09a3\u0005\u0001\u0000\u0000\u099e\u09a3"+ | |
| "\u0003\u0092I\u0000\u099f\u09a3\u0005\u0006\u0000\u0000\u09a0\u09a3\u0003"+ | |
| "\u0094J\u0000\u09a1\u09a3\u0003\u0090H\u0000\u09a2\u097e\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u097f\u0001\u0000\u0000\u0000\u09a2\u0980\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u0981\u0001\u0000\u0000\u0000\u09a2\u0982\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u0983\u0001\u0000\u0000\u0000\u09a2\u0984\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u0985\u0001\u0000\u0000\u0000\u09a2\u0986\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u0987\u0001\u0000\u0000\u0000\u09a2\u0988\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u0989\u0001\u0000\u0000\u0000\u09a2\u098a\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u098b\u0001\u0000\u0000\u0000\u09a2\u098c\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u098d\u0001\u0000\u0000\u0000\u09a2\u098e\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u098f\u0001\u0000\u0000\u0000\u09a2\u0990\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u0991\u0001\u0000\u0000\u0000\u09a2\u0992\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u0993\u0001\u0000\u0000\u0000\u09a2\u0994\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u0995\u0001\u0000\u0000\u0000\u09a2\u0996\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u0997\u0001\u0000\u0000\u0000\u09a2\u0998\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u0999\u0001\u0000\u0000\u0000\u09a2\u099a\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u099b\u0001\u0000\u0000\u0000\u09a2\u099c\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u099e\u0001\u0000\u0000\u0000\u09a2\u099f\u0001\u0000\u0000"+ | |
| "\u0000\u09a2\u09a0\u0001\u0000\u0000\u0000\u09a2\u09a1\u0001\u0000\u0000"+ | |
| "\u0000\u09a3\u09a6\u0001\u0000\u0000\u0000\u09a4\u09a2\u0001\u0000\u0000"+ | |
| "\u0000\u09a4\u09a5\u0001\u0000\u0000\u0000\u09a5\u09a7\u0001\u0000\u0000"+ | |
| "\u0000\u09a6\u09a4\u0001\u0000\u0000\u0000\u09a7\u09a8\u0003\u00ba]\u0000"+ | |
| "\u09a8\u00bd\u0001\u0000\u0000\u0000\u00d9\u00c5\u00c7\u00cb\u00d0\u00d6"+ | |
| "\u0119\u0121\u0123\u012e\u0137\u013e\u0144\u014e\u0150\u015c\u015e\u0169"+ | |
| "\u019d\u019f\u01aa\u01ac\u01b7\u01eb\u01ed\u01f8\u01fa\u0205\u0239\u023b"+ | |
| "\u0246\u0248\u0253\u0287\u0289\u0294\u0296\u02a1\u02d5\u02d7\u02e2\u02e4"+ | |
| "\u02ef\u0323\u0325\u0330\u0332\u033d\u0371\u0373\u037e\u0380\u038b\u03bf"+ | |
| "\u03c1\u03cc\u03ce\u03d9\u040d\u040f\u041a\u041c\u0427\u045b\u045d\u0468"+ | |
| "\u046a\u0475\u04a9\u04ab\u04b6\u04b8\u04c3\u04f7\u04f9\u0504\u0506\u0511"+ | |
| "\u0545\u0547\u0552\u0554\u055f\u0593\u0595\u05a0\u05a2\u05ad\u05e1\u05e3"+ | |
| "\u05fc\u0604\u0606\u0611\u0613\u061e\u0620\u062b\u062d\u0638\u063a\u0645"+ | |
| "\u0647\u0652\u0654\u065f\u0661\u066c\u066e\u0679\u067b\u0686\u0688\u0693"+ | |
| "\u0695\u06a0\u06a2\u06ad\u06af\u06c3\u06c5\u06cb\u06cd\u06d2\u06d4\u06da"+ | |
| "\u06e3\u06ea\u06ef\u06f6\u06f8\u06fe\u0703\u070a\u070c\u0712\u0717\u071d"+ | |
| "\u0725\u0727\u072c\u0731\u0736\u073c\u0743\u0748\u074f\u0754\u075a\u075f"+ | |
| "\u0764\u0769\u076e\u0773\u0779\u0781\u0783\u0789\u078e\u0794\u079b\u07a0"+ | |
| "\u07a2\u07aa\u07ac\u07b3\u07ba\u07c1\u07c7\u07cc\u07d2\u07d8\u07dd\u07e4"+ | |
| "\u07e6\u07ed\u07f2\u07f8\u07fd\u07ff\u0807\u0809\u0812\u081a\u081c\u0827"+ | |
| "\u0829\u0834\u0836\u0841\u0843\u084e\u0850\u085b\u085d\u0868\u0892\u0894"+ | |
| "\u089f\u08a1\u08ac\u08d6\u08d8\u08e3\u08e5\u08f0\u091a\u091c\u0927\u0929"+ | |
| "\u0934\u095e\u0960\u096b\u096d\u0978\u09a2\u09a4"; | |
| public static final String _serializedATN = Utils.join( | |
| new String[] { | |
| _serializedATNSegment0, | |
| _serializedATNSegment1 | |
| }, | |
| "" | |
| ); | |
| public static final ATN _ATN = | |
| new ATNDeserializer().deserialize(_serializedATN.toCharArray()); | |
| static { | |
| _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; | |
| for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { | |
| _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); | |
| } | |
| } | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment