Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.testingisdocumenting.znai.cpp.parser.CPP14Parser Maven / Gradle / Ivy
// Generated from org/testingisdocumenting/znai/cpp/parser/CPP14.g4 by ANTLR 4.5
package org.testingisdocumenting.znai.cpp.parser;
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 CPP14Parser extends Parser {
static { RuntimeMetaData.checkVersion("4.5", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
MultiLineMacro=1, Directive=2, Alignas=3, Alignof=4, Asm=5, Auto=6, Bool=7,
Break=8, Case=9, Catch=10, Char=11, Char16=12, Char32=13, Class=14, Const=15,
Constexpr=16, Const_cast=17, Continue=18, Decltype=19, Default=20, Delete=21,
Do=22, Double=23, Dynamic_cast=24, Else=25, Enum=26, Explicit=27, Export=28,
Extern=29, False=30, Final=31, Float=32, For=33, Friend=34, Goto=35, If=36,
Inline=37, Int=38, Long=39, Mutable=40, Namespace=41, New=42, Noexcept=43,
Nullptr=44, Operator=45, Override=46, Private=47, Protected=48, Public=49,
Register=50, Reinterpret_cast=51, Return=52, Short=53, Signed=54, Sizeof=55,
Static=56, Static_assert=57, Static_cast=58, Struct=59, Switch=60, Template=61,
This=62, Thread_local=63, Throw=64, True=65, Try=66, Typedef=67, Typeid=68,
Typename=69, Union=70, Unsigned=71, Using=72, Virtual=73, Void=74, Volatile=75,
Wchar=76, While=77, LeftParen=78, RightParen=79, LeftBracket=80, RightBracket=81,
LeftBrace=82, RightBrace=83, Plus=84, Minus=85, Star=86, Div=87, Mod=88,
Caret=89, And=90, Or=91, Tilde=92, Not=93, Assign=94, Less=95, Greater=96,
PlusAssign=97, MinusAssign=98, StarAssign=99, DivAssign=100, ModAssign=101,
XorAssign=102, AndAssign=103, OrAssign=104, LeftShift=105, LeftShiftAssign=106,
Equal=107, NotEqual=108, LessEqual=109, GreaterEqual=110, AndAnd=111,
OrOr=112, PlusPlus=113, MinusMinus=114, Comma=115, ArrowStar=116, Arrow=117,
Question=118, Colon=119, Doublecolon=120, Semi=121, Dot=122, DotStar=123,
Ellipsis=124, Identifier=125, Integerliteral=126, Decimalliteral=127,
Octalliteral=128, Hexadecimalliteral=129, Binaryliteral=130, Integersuffix=131,
Characterliteral=132, Floatingliteral=133, Stringliteral=134, Userdefinedintegerliteral=135,
Userdefinedfloatingliteral=136, Userdefinedstringliteral=137, Userdefinedcharacterliteral=138,
Whitespace=139, Newline=140, BlockComment=141, LineComment=142;
public static final int
RULE_translationunit = 0, RULE_primaryexpression = 1, RULE_idexpression = 2,
RULE_unqualifiedid = 3, RULE_qualifiedid = 4, RULE_nestednamespecifier = 5,
RULE_lambdaexpression = 6, RULE_lambdaintroducer = 7, RULE_lambdacapture = 8,
RULE_capturedefault = 9, RULE_capturelist = 10, RULE_capture = 11, RULE_simplecapture = 12,
RULE_initcapture = 13, RULE_lambdadeclarator = 14, RULE_postfixexpression = 15,
RULE_expressionlist = 16, RULE_pseudodestructorname = 17, RULE_unaryexpression = 18,
RULE_unaryoperator = 19, RULE_newexpression = 20, RULE_newplacement = 21,
RULE_newtypeid = 22, RULE_newdeclarator = 23, RULE_noptrnewdeclarator = 24,
RULE_newinitializer = 25, RULE_deleteexpression = 26, RULE_noexceptexpression = 27,
RULE_castexpression = 28, RULE_pmexpression = 29, RULE_multiplicativeexpression = 30,
RULE_additiveexpression = 31, RULE_shiftexpression = 32, RULE_relationalexpression = 33,
RULE_equalityexpression = 34, RULE_andexpression = 35, RULE_exclusiveorexpression = 36,
RULE_inclusiveorexpression = 37, RULE_logicalandexpression = 38, RULE_logicalorexpression = 39,
RULE_conditionalexpression = 40, RULE_assignmentexpression = 41, RULE_assignmentoperator = 42,
RULE_expression = 43, RULE_constantexpression = 44, RULE_statement = 45,
RULE_labeledstatement = 46, RULE_expressionstatement = 47, RULE_compoundstatement = 48,
RULE_statementseq = 49, RULE_selectionstatement = 50, RULE_condition = 51,
RULE_iterationstatement = 52, RULE_forinitstatement = 53, RULE_forrangedeclaration = 54,
RULE_forrangeinitializer = 55, RULE_jumpstatement = 56, RULE_declarationstatement = 57,
RULE_declarationseq = 58, RULE_declaration = 59, RULE_blockdeclaration = 60,
RULE_aliasdeclaration = 61, RULE_simpledeclaration = 62, RULE_static_assertdeclaration = 63,
RULE_emptydeclaration = 64, RULE_attributedeclaration = 65, RULE_declspecifier = 66,
RULE_declspecifierseq = 67, RULE_storageclassspecifier = 68, RULE_functionspecifier = 69,
RULE_typedefname = 70, RULE_typespecifier = 71, RULE_trailingtypespecifier = 72,
RULE_typespecifierseq = 73, RULE_trailingtypespecifierseq = 74, RULE_simpletypespecifier = 75,
RULE_typename = 76, RULE_decltypespecifier = 77, RULE_elaboratedtypespecifier = 78,
RULE_enumname = 79, RULE_enumspecifier = 80, RULE_enumhead = 81, RULE_opaqueenumdeclaration = 82,
RULE_enumkey = 83, RULE_enumbase = 84, RULE_enumeratorlist = 85, RULE_enumeratordefinition = 86,
RULE_enumerator = 87, RULE_namespacename = 88, RULE_originalnamespacename = 89,
RULE_namespacedefinition = 90, RULE_namednamespacedefinition = 91, RULE_originalnamespacedefinition = 92,
RULE_extensionnamespacedefinition = 93, RULE_unnamednamespacedefinition = 94,
RULE_namespacebody = 95, RULE_namespacealias = 96, RULE_namespacealiasdefinition = 97,
RULE_qualifiednamespacespecifier = 98, RULE_usingdeclaration = 99, RULE_usingdirective = 100,
RULE_asmdefinition = 101, RULE_linkagespecification = 102, RULE_attributespecifierseq = 103,
RULE_attributespecifier = 104, RULE_alignmentspecifier = 105, RULE_attributelist = 106,
RULE_attribute = 107, RULE_attributetoken = 108, RULE_attributescopedtoken = 109,
RULE_attributenamespace = 110, RULE_attributeargumentclause = 111, RULE_balancedtokenseq = 112,
RULE_balancedtoken = 113, RULE_initdeclaratorlist = 114, RULE_initdeclarator = 115,
RULE_declarator = 116, RULE_ptrdeclarator = 117, RULE_noptrdeclarator = 118,
RULE_parametersandqualifiers = 119, RULE_trailingreturntype = 120, RULE_ptroperator = 121,
RULE_cvqualifierseq = 122, RULE_cvqualifier = 123, RULE_refqualifier = 124,
RULE_declaratorid = 125, RULE_typeid = 126, RULE_abstractdeclarator = 127,
RULE_ptrabstractdeclarator = 128, RULE_noptrabstractdeclarator = 129,
RULE_abstractpackdeclarator = 130, RULE_noptrabstractpackdeclarator = 131,
RULE_parameterdeclarationclause = 132, RULE_parameterdeclarationlist = 133,
RULE_parameterdeclaration = 134, RULE_functiondefinition = 135, RULE_functionbody = 136,
RULE_initializer = 137, RULE_braceorequalinitializer = 138, RULE_initializerclause = 139,
RULE_initializerlist = 140, RULE_bracedinitlist = 141, RULE_classname = 142,
RULE_classspecifier = 143, RULE_classhead = 144, RULE_classheadname = 145,
RULE_classvirtspecifier = 146, RULE_classkey = 147, RULE_memberspecification = 148,
RULE_memberdeclaration = 149, RULE_memberdeclaratorlist = 150, RULE_memberdeclarator = 151,
RULE_virtspecifierseq = 152, RULE_virtspecifier = 153, RULE_purespecifier = 154,
RULE_baseclause = 155, RULE_basespecifierlist = 156, RULE_basespecifier = 157,
RULE_classordecltype = 158, RULE_basetypespecifier = 159, RULE_accessspecifier = 160,
RULE_conversionfunctionid = 161, RULE_conversiontypeid = 162, RULE_conversiondeclarator = 163,
RULE_ctorinitializer = 164, RULE_meminitializerlist = 165, RULE_meminitializer = 166,
RULE_meminitializerid = 167, RULE_operatorfunctionid = 168, RULE_literaloperatorid = 169,
RULE_templatedeclaration = 170, RULE_templateparameterlist = 171, RULE_templateparameter = 172,
RULE_typeparameter = 173, RULE_simpletemplateid = 174, RULE_templateid = 175,
RULE_templatename = 176, RULE_templateargumentlist = 177, RULE_templateargument = 178,
RULE_typenamespecifier = 179, RULE_explicitinstantiation = 180, RULE_explicitspecialization = 181,
RULE_tryblock = 182, RULE_functiontryblock = 183, RULE_handlerseq = 184,
RULE_handler = 185, RULE_exceptiondeclaration = 186, RULE_throwexpression = 187,
RULE_exceptionspecification = 188, RULE_dynamicexceptionspecification = 189,
RULE_typeidlist = 190, RULE_noexceptspecification = 191, RULE_rightShift = 192,
RULE_rightShiftAssign = 193, RULE_operator = 194, RULE_literal = 195,
RULE_booleanliteral = 196, RULE_pointerliteral = 197, RULE_userdefinedliteral = 198;
public static final String[] ruleNames = {
"translationunit", "primaryexpression", "idexpression", "unqualifiedid",
"qualifiedid", "nestednamespecifier", "lambdaexpression", "lambdaintroducer",
"lambdacapture", "capturedefault", "capturelist", "capture", "simplecapture",
"initcapture", "lambdadeclarator", "postfixexpression", "expressionlist",
"pseudodestructorname", "unaryexpression", "unaryoperator", "newexpression",
"newplacement", "newtypeid", "newdeclarator", "noptrnewdeclarator", "newinitializer",
"deleteexpression", "noexceptexpression", "castexpression", "pmexpression",
"multiplicativeexpression", "additiveexpression", "shiftexpression", "relationalexpression",
"equalityexpression", "andexpression", "exclusiveorexpression", "inclusiveorexpression",
"logicalandexpression", "logicalorexpression", "conditionalexpression",
"assignmentexpression", "assignmentoperator", "expression", "constantexpression",
"statement", "labeledstatement", "expressionstatement", "compoundstatement",
"statementseq", "selectionstatement", "condition", "iterationstatement",
"forinitstatement", "forrangedeclaration", "forrangeinitializer", "jumpstatement",
"declarationstatement", "declarationseq", "declaration", "blockdeclaration",
"aliasdeclaration", "simpledeclaration", "static_assertdeclaration", "emptydeclaration",
"attributedeclaration", "declspecifier", "declspecifierseq", "storageclassspecifier",
"functionspecifier", "typedefname", "typespecifier", "trailingtypespecifier",
"typespecifierseq", "trailingtypespecifierseq", "simpletypespecifier",
"typename", "decltypespecifier", "elaboratedtypespecifier", "enumname",
"enumspecifier", "enumhead", "opaqueenumdeclaration", "enumkey", "enumbase",
"enumeratorlist", "enumeratordefinition", "enumerator", "namespacename",
"originalnamespacename", "namespacedefinition", "namednamespacedefinition",
"originalnamespacedefinition", "extensionnamespacedefinition", "unnamednamespacedefinition",
"namespacebody", "namespacealias", "namespacealiasdefinition", "qualifiednamespacespecifier",
"usingdeclaration", "usingdirective", "asmdefinition", "linkagespecification",
"attributespecifierseq", "attributespecifier", "alignmentspecifier", "attributelist",
"attribute", "attributetoken", "attributescopedtoken", "attributenamespace",
"attributeargumentclause", "balancedtokenseq", "balancedtoken", "initdeclaratorlist",
"initdeclarator", "declarator", "ptrdeclarator", "noptrdeclarator", "parametersandqualifiers",
"trailingreturntype", "ptroperator", "cvqualifierseq", "cvqualifier",
"refqualifier", "declaratorid", "typeid", "abstractdeclarator", "ptrabstractdeclarator",
"noptrabstractdeclarator", "abstractpackdeclarator", "noptrabstractpackdeclarator",
"parameterdeclarationclause", "parameterdeclarationlist", "parameterdeclaration",
"functiondefinition", "functionbody", "initializer", "braceorequalinitializer",
"initializerclause", "initializerlist", "bracedinitlist", "classname",
"classspecifier", "classhead", "classheadname", "classvirtspecifier",
"classkey", "memberspecification", "memberdeclaration", "memberdeclaratorlist",
"memberdeclarator", "virtspecifierseq", "virtspecifier", "purespecifier",
"baseclause", "basespecifierlist", "basespecifier", "classordecltype",
"basetypespecifier", "accessspecifier", "conversionfunctionid", "conversiontypeid",
"conversiondeclarator", "ctorinitializer", "meminitializerlist", "meminitializer",
"meminitializerid", "operatorfunctionid", "literaloperatorid", "templatedeclaration",
"templateparameterlist", "templateparameter", "typeparameter", "simpletemplateid",
"templateid", "templatename", "templateargumentlist", "templateargument",
"typenamespecifier", "explicitinstantiation", "explicitspecialization",
"tryblock", "functiontryblock", "handlerseq", "handler", "exceptiondeclaration",
"throwexpression", "exceptionspecification", "dynamicexceptionspecification",
"typeidlist", "noexceptspecification", "rightShift", "rightShiftAssign",
"operator", "literal", "booleanliteral", "pointerliteral", "userdefinedliteral"
};
private static final String[] _LITERAL_NAMES = {
null, null, null, "'alignas'", "'alignof'", "'asm'", "'auto'", "'bool'",
"'break'", "'case'", "'catch'", "'char'", "'char16_t'", "'char32_t'",
"'class'", "'const'", "'constexpr'", "'const_cast'", "'continue'", "'decltype'",
"'default'", "'delete'", "'do'", "'double'", "'dynamic_cast'", "'else'",
"'enum'", "'explicit'", "'export'", "'extern'", "'false'", "'final'",
"'float'", "'for'", "'friend'", "'goto'", "'if'", "'inline'", "'int'",
"'long'", "'mutable'", "'namespace'", "'new'", "'noexcept'", "'nullptr'",
"'operator'", "'override'", "'private'", "'protected'", "'public'", "'register'",
"'reinterpret_cast'", "'return'", "'short'", "'signed'", "'sizeof'", "'static'",
"'static_assert'", "'static_cast'", "'struct'", "'switch'", "'template'",
"'this'", "'thread_local'", "'throw'", "'true'", "'try'", "'typedef'",
"'typeid'", "'typename'", "'union'", "'unsigned'", "'using'", "'virtual'",
"'void'", "'volatile'", "'wchar_t'", "'while'", "'('", "')'", "'['", "']'",
"'{'", "'}'", "'+'", "'-'", "'*'", "'/'", "'%'", "'^'", "'&'", "'|'",
"'~'", "'!'", "'='", "'<'", "'>'", "'+='", "'-='", "'*='", "'/='", "'%='",
"'^='", "'&='", "'|='", "'<<'", "'<<='", "'=='", "'!='", "'<='", "'>='",
"'&&'", "'||'", "'++'", "'--'", "','", "'->*'", "'->'", "'?'", "':'",
"'::'", "';'", "'.'", "'.*'", "'...'"
};
private static final String[] _SYMBOLIC_NAMES = {
null, "MultiLineMacro", "Directive", "Alignas", "Alignof", "Asm", "Auto",
"Bool", "Break", "Case", "Catch", "Char", "Char16", "Char32", "Class",
"Const", "Constexpr", "Const_cast", "Continue", "Decltype", "Default",
"Delete", "Do", "Double", "Dynamic_cast", "Else", "Enum", "Explicit",
"Export", "Extern", "False", "Final", "Float", "For", "Friend", "Goto",
"If", "Inline", "Int", "Long", "Mutable", "Namespace", "New", "Noexcept",
"Nullptr", "Operator", "Override", "Private", "Protected", "Public", "Register",
"Reinterpret_cast", "Return", "Short", "Signed", "Sizeof", "Static", "Static_assert",
"Static_cast", "Struct", "Switch", "Template", "This", "Thread_local",
"Throw", "True", "Try", "Typedef", "Typeid", "Typename", "Union", "Unsigned",
"Using", "Virtual", "Void", "Volatile", "Wchar", "While", "LeftParen",
"RightParen", "LeftBracket", "RightBracket", "LeftBrace", "RightBrace",
"Plus", "Minus", "Star", "Div", "Mod", "Caret", "And", "Or", "Tilde",
"Not", "Assign", "Less", "Greater", "PlusAssign", "MinusAssign", "StarAssign",
"DivAssign", "ModAssign", "XorAssign", "AndAssign", "OrAssign", "LeftShift",
"LeftShiftAssign", "Equal", "NotEqual", "LessEqual", "GreaterEqual", "AndAnd",
"OrOr", "PlusPlus", "MinusMinus", "Comma", "ArrowStar", "Arrow", "Question",
"Colon", "Doublecolon", "Semi", "Dot", "DotStar", "Ellipsis", "Identifier",
"Integerliteral", "Decimalliteral", "Octalliteral", "Hexadecimalliteral",
"Binaryliteral", "Integersuffix", "Characterliteral", "Floatingliteral",
"Stringliteral", "Userdefinedintegerliteral", "Userdefinedfloatingliteral",
"Userdefinedstringliteral", "Userdefinedcharacterliteral", "Whitespace",
"Newline", "BlockComment", "LineComment"
};
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] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "CPP14.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public CPP14Parser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class TranslationunitContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(CPP14Parser.EOF, 0); }
public DeclarationseqContext declarationseq() {
return getRuleContext(DeclarationseqContext.class,0);
}
public TranslationunitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_translationunit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTranslationunit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTranslationunit(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTranslationunit(this);
else return visitor.visitChildren(this);
}
}
public final TranslationunitContext translationunit() throws RecognitionException {
TranslationunitContext _localctx = new TranslationunitContext(_ctx, getState());
enterRule(_localctx, 0, RULE_translationunit);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(399);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignas) | (1L << Asm) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Decltype) | (1L << Double) | (1L << Enum) | (1L << Explicit) | (1L << Extern) | (1L << Float) | (1L << Friend) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << Namespace) | (1L << Operator) | (1L << Register) | (1L << Short) | (1L << Signed) | (1L << Static) | (1L << Static_assert) | (1L << Struct) | (1L << Template) | (1L << Thread_local))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (Typedef - 67)) | (1L << (Typename - 67)) | (1L << (Union - 67)) | (1L << (Unsigned - 67)) | (1L << (Using - 67)) | (1L << (Virtual - 67)) | (1L << (Void - 67)) | (1L << (Volatile - 67)) | (1L << (Wchar - 67)) | (1L << (LeftParen - 67)) | (1L << (LeftBracket - 67)) | (1L << (Star - 67)) | (1L << (And - 67)) | (1L << (Tilde - 67)) | (1L << (AndAnd - 67)) | (1L << (Doublecolon - 67)) | (1L << (Semi - 67)) | (1L << (Ellipsis - 67)) | (1L << (Identifier - 67)))) != 0)) {
{
setState(398);
declarationseq(0);
}
}
setState(401);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PrimaryexpressionContext extends ParserRuleContext {
public LiteralContext literal() {
return getRuleContext(LiteralContext.class,0);
}
public TerminalNode This() { return getToken(CPP14Parser.This, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public IdexpressionContext idexpression() {
return getRuleContext(IdexpressionContext.class,0);
}
public LambdaexpressionContext lambdaexpression() {
return getRuleContext(LambdaexpressionContext.class,0);
}
public PrimaryexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPrimaryexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPrimaryexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitPrimaryexpression(this);
else return visitor.visitChildren(this);
}
}
public final PrimaryexpressionContext primaryexpression() throws RecognitionException {
PrimaryexpressionContext _localctx = new PrimaryexpressionContext(_ctx, getState());
enterRule(_localctx, 2, RULE_primaryexpression);
try {
setState(411);
switch (_input.LA(1)) {
case False:
case Nullptr:
case True:
case Integerliteral:
case Characterliteral:
case Floatingliteral:
case Stringliteral:
case Userdefinedintegerliteral:
case Userdefinedfloatingliteral:
case Userdefinedstringliteral:
case Userdefinedcharacterliteral:
enterOuterAlt(_localctx, 1);
{
setState(403);
literal();
}
break;
case This:
enterOuterAlt(_localctx, 2);
{
setState(404);
match(This);
}
break;
case LeftParen:
enterOuterAlt(_localctx, 3);
{
setState(405);
match(LeftParen);
setState(406);
expression(0);
setState(407);
match(RightParen);
}
break;
case Decltype:
case Operator:
case Tilde:
case Doublecolon:
case Identifier:
enterOuterAlt(_localctx, 4);
{
setState(409);
idexpression();
}
break;
case LeftBracket:
enterOuterAlt(_localctx, 5);
{
setState(410);
lambdaexpression();
}
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 IdexpressionContext extends ParserRuleContext {
public UnqualifiedidContext unqualifiedid() {
return getRuleContext(UnqualifiedidContext.class,0);
}
public QualifiedidContext qualifiedid() {
return getRuleContext(QualifiedidContext.class,0);
}
public IdexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_idexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterIdexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitIdexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitIdexpression(this);
else return visitor.visitChildren(this);
}
}
public final IdexpressionContext idexpression() throws RecognitionException {
IdexpressionContext _localctx = new IdexpressionContext(_ctx, getState());
enterRule(_localctx, 4, RULE_idexpression);
try {
setState(415);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(413);
unqualifiedid();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(414);
qualifiedid();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnqualifiedidContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public OperatorfunctionidContext operatorfunctionid() {
return getRuleContext(OperatorfunctionidContext.class,0);
}
public ConversionfunctionidContext conversionfunctionid() {
return getRuleContext(ConversionfunctionidContext.class,0);
}
public LiteraloperatoridContext literaloperatorid() {
return getRuleContext(LiteraloperatoridContext.class,0);
}
public ClassnameContext classname() {
return getRuleContext(ClassnameContext.class,0);
}
public DecltypespecifierContext decltypespecifier() {
return getRuleContext(DecltypespecifierContext.class,0);
}
public TemplateidContext templateid() {
return getRuleContext(TemplateidContext.class,0);
}
public UnqualifiedidContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unqualifiedid; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterUnqualifiedid(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitUnqualifiedid(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitUnqualifiedid(this);
else return visitor.visitChildren(this);
}
}
public final UnqualifiedidContext unqualifiedid() throws RecognitionException {
UnqualifiedidContext _localctx = new UnqualifiedidContext(_ctx, getState());
enterRule(_localctx, 6, RULE_unqualifiedid);
try {
setState(426);
switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(417);
match(Identifier);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(418);
operatorfunctionid();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(419);
conversionfunctionid();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(420);
literaloperatorid();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(421);
match(Tilde);
setState(422);
classname();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(423);
match(Tilde);
setState(424);
decltypespecifier();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(425);
templateid();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualifiedidContext extends ParserRuleContext {
public NestednamespecifierContext nestednamespecifier() {
return getRuleContext(NestednamespecifierContext.class,0);
}
public UnqualifiedidContext unqualifiedid() {
return getRuleContext(UnqualifiedidContext.class,0);
}
public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
public QualifiedidContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiedid; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterQualifiedid(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitQualifiedid(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitQualifiedid(this);
else return visitor.visitChildren(this);
}
}
public final QualifiedidContext qualifiedid() throws RecognitionException {
QualifiedidContext _localctx = new QualifiedidContext(_ctx, getState());
enterRule(_localctx, 8, RULE_qualifiedid);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(428);
nestednamespecifier(0);
setState(430);
_la = _input.LA(1);
if (_la==Template) {
{
setState(429);
match(Template);
}
}
setState(432);
unqualifiedid();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NestednamespecifierContext extends ParserRuleContext {
public TypenameContext typename() {
return getRuleContext(TypenameContext.class,0);
}
public NamespacenameContext namespacename() {
return getRuleContext(NamespacenameContext.class,0);
}
public DecltypespecifierContext decltypespecifier() {
return getRuleContext(DecltypespecifierContext.class,0);
}
public NestednamespecifierContext nestednamespecifier() {
return getRuleContext(NestednamespecifierContext.class,0);
}
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public SimpletemplateidContext simpletemplateid() {
return getRuleContext(SimpletemplateidContext.class,0);
}
public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
public NestednamespecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nestednamespecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNestednamespecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNestednamespecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNestednamespecifier(this);
else return visitor.visitChildren(this);
}
}
public final NestednamespecifierContext nestednamespecifier() throws RecognitionException {
return nestednamespecifier(0);
}
private NestednamespecifierContext nestednamespecifier(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
NestednamespecifierContext _localctx = new NestednamespecifierContext(_ctx, _parentState);
NestednamespecifierContext _prevctx = _localctx;
int _startState = 10;
enterRecursionRule(_localctx, 10, RULE_nestednamespecifier, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(445);
switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
case 1:
{
setState(435);
match(Doublecolon);
}
break;
case 2:
{
setState(436);
typename();
setState(437);
match(Doublecolon);
}
break;
case 3:
{
setState(439);
namespacename();
setState(440);
match(Doublecolon);
}
break;
case 4:
{
setState(442);
decltypespecifier();
setState(443);
match(Doublecolon);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(459);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(457);
switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
case 1:
{
_localctx = new NestednamespecifierContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_nestednamespecifier);
setState(447);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(448);
match(Identifier);
setState(449);
match(Doublecolon);
}
break;
case 2:
{
_localctx = new NestednamespecifierContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_nestednamespecifier);
setState(450);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(452);
_la = _input.LA(1);
if (_la==Template) {
{
setState(451);
match(Template);
}
}
setState(454);
simpletemplateid();
setState(455);
match(Doublecolon);
}
break;
}
}
}
setState(461);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,8,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class LambdaexpressionContext extends ParserRuleContext {
public LambdaintroducerContext lambdaintroducer() {
return getRuleContext(LambdaintroducerContext.class,0);
}
public CompoundstatementContext compoundstatement() {
return getRuleContext(CompoundstatementContext.class,0);
}
public LambdadeclaratorContext lambdadeclarator() {
return getRuleContext(LambdadeclaratorContext.class,0);
}
public LambdaexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lambdaexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLambdaexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLambdaexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitLambdaexpression(this);
else return visitor.visitChildren(this);
}
}
public final LambdaexpressionContext lambdaexpression() throws RecognitionException {
LambdaexpressionContext _localctx = new LambdaexpressionContext(_ctx, getState());
enterRule(_localctx, 12, RULE_lambdaexpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(462);
lambdaintroducer();
setState(464);
_la = _input.LA(1);
if (_la==LeftParen) {
{
setState(463);
lambdadeclarator();
}
}
setState(466);
compoundstatement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LambdaintroducerContext extends ParserRuleContext {
public LambdacaptureContext lambdacapture() {
return getRuleContext(LambdacaptureContext.class,0);
}
public LambdaintroducerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lambdaintroducer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLambdaintroducer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLambdaintroducer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitLambdaintroducer(this);
else return visitor.visitChildren(this);
}
}
public final LambdaintroducerContext lambdaintroducer() throws RecognitionException {
LambdaintroducerContext _localctx = new LambdaintroducerContext(_ctx, getState());
enterRule(_localctx, 14, RULE_lambdaintroducer);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(468);
match(LeftBracket);
setState(470);
_la = _input.LA(1);
if (((((_la - 62)) & ~0x3f) == 0 && ((1L << (_la - 62)) & ((1L << (This - 62)) | (1L << (And - 62)) | (1L << (Assign - 62)) | (1L << (Identifier - 62)))) != 0)) {
{
setState(469);
lambdacapture();
}
}
setState(472);
match(RightBracket);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LambdacaptureContext extends ParserRuleContext {
public CapturedefaultContext capturedefault() {
return getRuleContext(CapturedefaultContext.class,0);
}
public CapturelistContext capturelist() {
return getRuleContext(CapturelistContext.class,0);
}
public LambdacaptureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lambdacapture; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLambdacapture(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLambdacapture(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitLambdacapture(this);
else return visitor.visitChildren(this);
}
}
public final LambdacaptureContext lambdacapture() throws RecognitionException {
LambdacaptureContext _localctx = new LambdacaptureContext(_ctx, getState());
enterRule(_localctx, 16, RULE_lambdacapture);
try {
setState(480);
switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(474);
capturedefault();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(475);
capturelist(0);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(476);
capturedefault();
setState(477);
match(Comma);
setState(478);
capturelist(0);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CapturedefaultContext extends ParserRuleContext {
public CapturedefaultContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_capturedefault; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCapturedefault(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCapturedefault(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitCapturedefault(this);
else return visitor.visitChildren(this);
}
}
public final CapturedefaultContext capturedefault() throws RecognitionException {
CapturedefaultContext _localctx = new CapturedefaultContext(_ctx, getState());
enterRule(_localctx, 18, RULE_capturedefault);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(482);
_la = _input.LA(1);
if ( !(_la==And || _la==Assign) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CapturelistContext extends ParserRuleContext {
public CaptureContext capture() {
return getRuleContext(CaptureContext.class,0);
}
public CapturelistContext capturelist() {
return getRuleContext(CapturelistContext.class,0);
}
public CapturelistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_capturelist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCapturelist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCapturelist(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitCapturelist(this);
else return visitor.visitChildren(this);
}
}
public final CapturelistContext capturelist() throws RecognitionException {
return capturelist(0);
}
private CapturelistContext capturelist(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
CapturelistContext _localctx = new CapturelistContext(_ctx, _parentState);
CapturelistContext _prevctx = _localctx;
int _startState = 20;
enterRecursionRule(_localctx, 20, RULE_capturelist, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(485);
capture();
setState(487);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
{
setState(486);
match(Ellipsis);
}
break;
}
}
_ctx.stop = _input.LT(-1);
setState(497);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new CapturelistContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_capturelist);
setState(489);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(490);
match(Comma);
setState(491);
capture();
setState(493);
switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
case 1:
{
setState(492);
match(Ellipsis);
}
break;
}
}
}
}
setState(499);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class CaptureContext extends ParserRuleContext {
public SimplecaptureContext simplecapture() {
return getRuleContext(SimplecaptureContext.class,0);
}
public InitcaptureContext initcapture() {
return getRuleContext(InitcaptureContext.class,0);
}
public CaptureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_capture; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCapture(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCapture(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitCapture(this);
else return visitor.visitChildren(this);
}
}
public final CaptureContext capture() throws RecognitionException {
CaptureContext _localctx = new CaptureContext(_ctx, getState());
enterRule(_localctx, 22, RULE_capture);
try {
setState(502);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(500);
simplecapture();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(501);
initcapture();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimplecaptureContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public TerminalNode This() { return getToken(CPP14Parser.This, 0); }
public SimplecaptureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simplecapture; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterSimplecapture(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitSimplecapture(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitSimplecapture(this);
else return visitor.visitChildren(this);
}
}
public final SimplecaptureContext simplecapture() throws RecognitionException {
SimplecaptureContext _localctx = new SimplecaptureContext(_ctx, getState());
enterRule(_localctx, 24, RULE_simplecapture);
try {
setState(508);
switch (_input.LA(1)) {
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(504);
match(Identifier);
}
break;
case And:
enterOuterAlt(_localctx, 2);
{
setState(505);
match(And);
setState(506);
match(Identifier);
}
break;
case This:
enterOuterAlt(_localctx, 3);
{
setState(507);
match(This);
}
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 InitcaptureContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public InitializerContext initializer() {
return getRuleContext(InitializerContext.class,0);
}
public InitcaptureContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_initcapture; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInitcapture(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInitcapture(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitInitcapture(this);
else return visitor.visitChildren(this);
}
}
public final InitcaptureContext initcapture() throws RecognitionException {
InitcaptureContext _localctx = new InitcaptureContext(_ctx, getState());
enterRule(_localctx, 26, RULE_initcapture);
try {
setState(515);
switch (_input.LA(1)) {
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(510);
match(Identifier);
setState(511);
initializer();
}
break;
case And:
enterOuterAlt(_localctx, 2);
{
setState(512);
match(And);
setState(513);
match(Identifier);
setState(514);
initializer();
}
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 LambdadeclaratorContext extends ParserRuleContext {
public ParameterdeclarationclauseContext parameterdeclarationclause() {
return getRuleContext(ParameterdeclarationclauseContext.class,0);
}
public TerminalNode Mutable() { return getToken(CPP14Parser.Mutable, 0); }
public ExceptionspecificationContext exceptionspecification() {
return getRuleContext(ExceptionspecificationContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public TrailingreturntypeContext trailingreturntype() {
return getRuleContext(TrailingreturntypeContext.class,0);
}
public LambdadeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_lambdadeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLambdadeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLambdadeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitLambdadeclarator(this);
else return visitor.visitChildren(this);
}
}
public final LambdadeclaratorContext lambdadeclarator() throws RecognitionException {
LambdadeclaratorContext _localctx = new LambdadeclaratorContext(_ctx, getState());
enterRule(_localctx, 28, RULE_lambdadeclarator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(517);
match(LeftParen);
setState(518);
parameterdeclarationclause();
setState(519);
match(RightParen);
setState(521);
_la = _input.LA(1);
if (_la==Mutable) {
{
setState(520);
match(Mutable);
}
}
setState(524);
_la = _input.LA(1);
if (_la==Noexcept || _la==Throw) {
{
setState(523);
exceptionspecification();
}
}
setState(527);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(526);
attributespecifierseq(0);
}
}
setState(530);
_la = _input.LA(1);
if (_la==Arrow) {
{
setState(529);
trailingreturntype();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PostfixexpressionContext extends ParserRuleContext {
public PrimaryexpressionContext primaryexpression() {
return getRuleContext(PrimaryexpressionContext.class,0);
}
public SimpletypespecifierContext simpletypespecifier() {
return getRuleContext(SimpletypespecifierContext.class,0);
}
public ExpressionlistContext expressionlist() {
return getRuleContext(ExpressionlistContext.class,0);
}
public TypenamespecifierContext typenamespecifier() {
return getRuleContext(TypenamespecifierContext.class,0);
}
public BracedinitlistContext bracedinitlist() {
return getRuleContext(BracedinitlistContext.class,0);
}
public TerminalNode Dynamic_cast() { return getToken(CPP14Parser.Dynamic_cast, 0); }
public TypeidContext typeid() {
return getRuleContext(TypeidContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode Static_cast() { return getToken(CPP14Parser.Static_cast, 0); }
public TerminalNode Reinterpret_cast() { return getToken(CPP14Parser.Reinterpret_cast, 0); }
public TerminalNode Const_cast() { return getToken(CPP14Parser.Const_cast, 0); }
public TerminalNode Typeid() { return getToken(CPP14Parser.Typeid, 0); }
public PostfixexpressionContext postfixexpression() {
return getRuleContext(PostfixexpressionContext.class,0);
}
public IdexpressionContext idexpression() {
return getRuleContext(IdexpressionContext.class,0);
}
public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
public PseudodestructornameContext pseudodestructorname() {
return getRuleContext(PseudodestructornameContext.class,0);
}
public PostfixexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postfixexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPostfixexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPostfixexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitPostfixexpression(this);
else return visitor.visitChildren(this);
}
}
public final PostfixexpressionContext postfixexpression() throws RecognitionException {
return postfixexpression(0);
}
private PostfixexpressionContext postfixexpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
PostfixexpressionContext _localctx = new PostfixexpressionContext(_ctx, _parentState);
PostfixexpressionContext _prevctx = _localctx;
int _startState = 30;
enterRecursionRule(_localctx, 30, RULE_postfixexpression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(596);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
{
setState(533);
primaryexpression();
}
break;
case 2:
{
setState(534);
simpletypespecifier();
setState(535);
match(LeftParen);
setState(537);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << False) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static_cast) | (1L << This))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Throw - 64)) | (1L << (True - 64)) | (1L << (Typeid - 64)) | (1L << (Typename - 64)) | (1L << (Unsigned - 64)) | (1L << (Void - 64)) | (1L << (Wchar - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (LeftBrace - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Doublecolon - 64)) | (1L << (Identifier - 64)) | (1L << (Integerliteral - 64)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(536);
expressionlist();
}
}
setState(539);
match(RightParen);
}
break;
case 3:
{
setState(541);
typenamespecifier();
setState(542);
match(LeftParen);
setState(544);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << False) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static_cast) | (1L << This))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Throw - 64)) | (1L << (True - 64)) | (1L << (Typeid - 64)) | (1L << (Typename - 64)) | (1L << (Unsigned - 64)) | (1L << (Void - 64)) | (1L << (Wchar - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (LeftBrace - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Doublecolon - 64)) | (1L << (Identifier - 64)) | (1L << (Integerliteral - 64)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(543);
expressionlist();
}
}
setState(546);
match(RightParen);
}
break;
case 4:
{
setState(548);
simpletypespecifier();
setState(549);
bracedinitlist();
}
break;
case 5:
{
setState(551);
typenamespecifier();
setState(552);
bracedinitlist();
}
break;
case 6:
{
setState(554);
match(Dynamic_cast);
setState(555);
match(Less);
setState(556);
typeid();
setState(557);
match(Greater);
setState(558);
match(LeftParen);
setState(559);
expression(0);
setState(560);
match(RightParen);
}
break;
case 7:
{
setState(562);
match(Static_cast);
setState(563);
match(Less);
setState(564);
typeid();
setState(565);
match(Greater);
setState(566);
match(LeftParen);
setState(567);
expression(0);
setState(568);
match(RightParen);
}
break;
case 8:
{
setState(570);
match(Reinterpret_cast);
setState(571);
match(Less);
setState(572);
typeid();
setState(573);
match(Greater);
setState(574);
match(LeftParen);
setState(575);
expression(0);
setState(576);
match(RightParen);
}
break;
case 9:
{
setState(578);
match(Const_cast);
setState(579);
match(Less);
setState(580);
typeid();
setState(581);
match(Greater);
setState(582);
match(LeftParen);
setState(583);
expression(0);
setState(584);
match(RightParen);
}
break;
case 10:
{
setState(586);
match(Typeid);
setState(587);
match(LeftParen);
setState(588);
expression(0);
setState(589);
match(RightParen);
}
break;
case 11:
{
setState(591);
match(Typeid);
setState(592);
match(LeftParen);
setState(593);
typeid();
setState(594);
match(RightParen);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(638);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(636);
switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) {
case 1:
{
_localctx = new PostfixexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
setState(598);
if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)");
setState(599);
match(LeftBracket);
setState(600);
expression(0);
setState(601);
match(RightBracket);
}
break;
case 2:
{
_localctx = new PostfixexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
setState(603);
if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
setState(604);
match(LeftBracket);
setState(605);
bracedinitlist();
setState(606);
match(RightBracket);
}
break;
case 3:
{
_localctx = new PostfixexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
setState(608);
if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
setState(609);
match(LeftParen);
setState(611);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << False) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static_cast) | (1L << This))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Throw - 64)) | (1L << (True - 64)) | (1L << (Typeid - 64)) | (1L << (Typename - 64)) | (1L << (Unsigned - 64)) | (1L << (Void - 64)) | (1L << (Wchar - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (LeftBrace - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Doublecolon - 64)) | (1L << (Identifier - 64)) | (1L << (Integerliteral - 64)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(610);
expressionlist();
}
}
setState(613);
match(RightParen);
}
break;
case 4:
{
_localctx = new PostfixexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
setState(614);
if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
setState(615);
match(Dot);
setState(617);
_la = _input.LA(1);
if (_la==Template) {
{
setState(616);
match(Template);
}
}
setState(619);
idexpression();
}
break;
case 5:
{
_localctx = new PostfixexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
setState(620);
if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
setState(621);
match(Arrow);
setState(623);
_la = _input.LA(1);
if (_la==Template) {
{
setState(622);
match(Template);
}
}
setState(625);
idexpression();
}
break;
case 6:
{
_localctx = new PostfixexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
setState(626);
if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
setState(627);
match(Dot);
setState(628);
pseudodestructorname();
}
break;
case 7:
{
_localctx = new PostfixexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
setState(629);
if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
setState(630);
match(Arrow);
setState(631);
pseudodestructorname();
}
break;
case 8:
{
_localctx = new PostfixexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
setState(632);
if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
setState(633);
match(PlusPlus);
}
break;
case 9:
{
_localctx = new PostfixexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_postfixexpression);
setState(634);
if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
setState(635);
match(MinusMinus);
}
break;
}
}
}
setState(640);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ExpressionlistContext extends ParserRuleContext {
public InitializerlistContext initializerlist() {
return getRuleContext(InitializerlistContext.class,0);
}
public ExpressionlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionlist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExpressionlist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExpressionlist(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitExpressionlist(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionlistContext expressionlist() throws RecognitionException {
ExpressionlistContext _localctx = new ExpressionlistContext(_ctx, getState());
enterRule(_localctx, 32, RULE_expressionlist);
try {
enterOuterAlt(_localctx, 1);
{
setState(641);
initializerlist(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PseudodestructornameContext extends ParserRuleContext {
public List typename() {
return getRuleContexts(TypenameContext.class);
}
public TypenameContext typename(int i) {
return getRuleContext(TypenameContext.class,i);
}
public NestednamespecifierContext nestednamespecifier() {
return getRuleContext(NestednamespecifierContext.class,0);
}
public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
public SimpletemplateidContext simpletemplateid() {
return getRuleContext(SimpletemplateidContext.class,0);
}
public DecltypespecifierContext decltypespecifier() {
return getRuleContext(DecltypespecifierContext.class,0);
}
public PseudodestructornameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pseudodestructorname; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPseudodestructorname(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPseudodestructorname(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitPseudodestructorname(this);
else return visitor.visitChildren(this);
}
}
public final PseudodestructornameContext pseudodestructorname() throws RecognitionException {
PseudodestructornameContext _localctx = new PseudodestructornameContext(_ctx, getState());
enterRule(_localctx, 34, RULE_pseudodestructorname);
int _la;
try {
setState(665);
switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(644);
switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
case 1:
{
setState(643);
nestednamespecifier(0);
}
break;
}
setState(646);
typename();
setState(647);
match(Doublecolon);
setState(648);
match(Tilde);
setState(649);
typename();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(651);
nestednamespecifier(0);
setState(652);
match(Template);
setState(653);
simpletemplateid();
setState(654);
match(Doublecolon);
setState(655);
match(Tilde);
setState(656);
typename();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(659);
_la = _input.LA(1);
if (_la==Decltype || _la==Doublecolon || _la==Identifier) {
{
setState(658);
nestednamespecifier(0);
}
}
setState(661);
match(Tilde);
setState(662);
typename();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(663);
match(Tilde);
setState(664);
decltypespecifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnaryexpressionContext extends ParserRuleContext {
public PostfixexpressionContext postfixexpression() {
return getRuleContext(PostfixexpressionContext.class,0);
}
public CastexpressionContext castexpression() {
return getRuleContext(CastexpressionContext.class,0);
}
public UnaryoperatorContext unaryoperator() {
return getRuleContext(UnaryoperatorContext.class,0);
}
public TerminalNode Sizeof() { return getToken(CPP14Parser.Sizeof, 0); }
public UnaryexpressionContext unaryexpression() {
return getRuleContext(UnaryexpressionContext.class,0);
}
public TypeidContext typeid() {
return getRuleContext(TypeidContext.class,0);
}
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public TerminalNode Alignof() { return getToken(CPP14Parser.Alignof, 0); }
public NoexceptexpressionContext noexceptexpression() {
return getRuleContext(NoexceptexpressionContext.class,0);
}
public NewexpressionContext newexpression() {
return getRuleContext(NewexpressionContext.class,0);
}
public DeleteexpressionContext deleteexpression() {
return getRuleContext(DeleteexpressionContext.class,0);
}
public UnaryexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterUnaryexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitUnaryexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitUnaryexpression(this);
else return visitor.visitChildren(this);
}
}
public final UnaryexpressionContext unaryexpression() throws RecognitionException {
UnaryexpressionContext _localctx = new UnaryexpressionContext(_ctx, getState());
enterRule(_localctx, 36, RULE_unaryexpression);
try {
setState(695);
switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(667);
postfixexpression(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(668);
match(PlusPlus);
setState(669);
castexpression();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(670);
match(MinusMinus);
setState(671);
castexpression();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(672);
unaryoperator();
setState(673);
castexpression();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(675);
match(Sizeof);
setState(676);
unaryexpression();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(677);
match(Sizeof);
setState(678);
match(LeftParen);
setState(679);
typeid();
setState(680);
match(RightParen);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(682);
match(Sizeof);
setState(683);
match(Ellipsis);
setState(684);
match(LeftParen);
setState(685);
match(Identifier);
setState(686);
match(RightParen);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(687);
match(Alignof);
setState(688);
match(LeftParen);
setState(689);
typeid();
setState(690);
match(RightParen);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(692);
noexceptexpression();
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(693);
newexpression();
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(694);
deleteexpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnaryoperatorContext extends ParserRuleContext {
public UnaryoperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryoperator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterUnaryoperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitUnaryoperator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitUnaryoperator(this);
else return visitor.visitChildren(this);
}
}
public final UnaryoperatorContext unaryoperator() throws RecognitionException {
UnaryoperatorContext _localctx = new UnaryoperatorContext(_ctx, getState());
enterRule(_localctx, 38, RULE_unaryoperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(697);
_la = _input.LA(1);
if ( !(((((_la - 84)) & ~0x3f) == 0 && ((1L << (_la - 84)) & ((1L << (Plus - 84)) | (1L << (Minus - 84)) | (1L << (Star - 84)) | (1L << (And - 84)) | (1L << (Or - 84)) | (1L << (Tilde - 84)) | (1L << (Not - 84)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NewexpressionContext extends ParserRuleContext {
public TerminalNode New() { return getToken(CPP14Parser.New, 0); }
public NewtypeidContext newtypeid() {
return getRuleContext(NewtypeidContext.class,0);
}
public NewplacementContext newplacement() {
return getRuleContext(NewplacementContext.class,0);
}
public NewinitializerContext newinitializer() {
return getRuleContext(NewinitializerContext.class,0);
}
public TypeidContext typeid() {
return getRuleContext(TypeidContext.class,0);
}
public NewexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_newexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNewexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNewexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNewexpression(this);
else return visitor.visitChildren(this);
}
}
public final NewexpressionContext newexpression() throws RecognitionException {
NewexpressionContext _localctx = new NewexpressionContext(_ctx, getState());
enterRule(_localctx, 40, RULE_newexpression);
int _la;
try {
setState(723);
switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(700);
_la = _input.LA(1);
if (_la==Doublecolon) {
{
setState(699);
match(Doublecolon);
}
}
setState(702);
match(New);
setState(704);
_la = _input.LA(1);
if (_la==LeftParen) {
{
setState(703);
newplacement();
}
}
setState(706);
newtypeid();
setState(708);
switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) {
case 1:
{
setState(707);
newinitializer();
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(711);
_la = _input.LA(1);
if (_la==Doublecolon) {
{
setState(710);
match(Doublecolon);
}
}
setState(713);
match(New);
setState(715);
switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) {
case 1:
{
setState(714);
newplacement();
}
break;
}
setState(717);
match(LeftParen);
setState(718);
typeid();
setState(719);
match(RightParen);
setState(721);
switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
case 1:
{
setState(720);
newinitializer();
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NewplacementContext extends ParserRuleContext {
public ExpressionlistContext expressionlist() {
return getRuleContext(ExpressionlistContext.class,0);
}
public NewplacementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_newplacement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNewplacement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNewplacement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNewplacement(this);
else return visitor.visitChildren(this);
}
}
public final NewplacementContext newplacement() throws RecognitionException {
NewplacementContext _localctx = new NewplacementContext(_ctx, getState());
enterRule(_localctx, 42, RULE_newplacement);
try {
enterOuterAlt(_localctx, 1);
{
setState(725);
match(LeftParen);
setState(726);
expressionlist();
setState(727);
match(RightParen);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NewtypeidContext extends ParserRuleContext {
public TypespecifierseqContext typespecifierseq() {
return getRuleContext(TypespecifierseqContext.class,0);
}
public NewdeclaratorContext newdeclarator() {
return getRuleContext(NewdeclaratorContext.class,0);
}
public NewtypeidContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_newtypeid; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNewtypeid(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNewtypeid(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNewtypeid(this);
else return visitor.visitChildren(this);
}
}
public final NewtypeidContext newtypeid() throws RecognitionException {
NewtypeidContext _localctx = new NewtypeidContext(_ctx, getState());
enterRule(_localctx, 44, RULE_newtypeid);
try {
enterOuterAlt(_localctx, 1);
{
setState(729);
typespecifierseq();
setState(731);
switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
case 1:
{
setState(730);
newdeclarator();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NewdeclaratorContext extends ParserRuleContext {
public PtroperatorContext ptroperator() {
return getRuleContext(PtroperatorContext.class,0);
}
public NewdeclaratorContext newdeclarator() {
return getRuleContext(NewdeclaratorContext.class,0);
}
public NoptrnewdeclaratorContext noptrnewdeclarator() {
return getRuleContext(NoptrnewdeclaratorContext.class,0);
}
public NewdeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_newdeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNewdeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNewdeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNewdeclarator(this);
else return visitor.visitChildren(this);
}
}
public final NewdeclaratorContext newdeclarator() throws RecognitionException {
NewdeclaratorContext _localctx = new NewdeclaratorContext(_ctx, getState());
enterRule(_localctx, 46, RULE_newdeclarator);
try {
setState(738);
switch (_input.LA(1)) {
case Decltype:
case Star:
case And:
case AndAnd:
case Doublecolon:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(733);
ptroperator();
setState(735);
switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) {
case 1:
{
setState(734);
newdeclarator();
}
break;
}
}
break;
case LeftBracket:
enterOuterAlt(_localctx, 2);
{
setState(737);
noptrnewdeclarator(0);
}
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 NoptrnewdeclaratorContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public NoptrnewdeclaratorContext noptrnewdeclarator() {
return getRuleContext(NoptrnewdeclaratorContext.class,0);
}
public ConstantexpressionContext constantexpression() {
return getRuleContext(ConstantexpressionContext.class,0);
}
public NoptrnewdeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_noptrnewdeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNoptrnewdeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNoptrnewdeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNoptrnewdeclarator(this);
else return visitor.visitChildren(this);
}
}
public final NoptrnewdeclaratorContext noptrnewdeclarator() throws RecognitionException {
return noptrnewdeclarator(0);
}
private NoptrnewdeclaratorContext noptrnewdeclarator(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
NoptrnewdeclaratorContext _localctx = new NoptrnewdeclaratorContext(_ctx, _parentState);
NoptrnewdeclaratorContext _prevctx = _localctx;
int _startState = 48;
enterRecursionRule(_localctx, 48, RULE_noptrnewdeclarator, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(741);
match(LeftBracket);
setState(742);
expression(0);
setState(743);
match(RightBracket);
setState(745);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
{
setState(744);
attributespecifierseq(0);
}
break;
}
}
_ctx.stop = _input.LT(-1);
setState(756);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,46,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new NoptrnewdeclaratorContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_noptrnewdeclarator);
setState(747);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(748);
match(LeftBracket);
setState(749);
constantexpression();
setState(750);
match(RightBracket);
setState(752);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
{
setState(751);
attributespecifierseq(0);
}
break;
}
}
}
}
setState(758);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,46,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class NewinitializerContext extends ParserRuleContext {
public ExpressionlistContext expressionlist() {
return getRuleContext(ExpressionlistContext.class,0);
}
public BracedinitlistContext bracedinitlist() {
return getRuleContext(BracedinitlistContext.class,0);
}
public NewinitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_newinitializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNewinitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNewinitializer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNewinitializer(this);
else return visitor.visitChildren(this);
}
}
public final NewinitializerContext newinitializer() throws RecognitionException {
NewinitializerContext _localctx = new NewinitializerContext(_ctx, getState());
enterRule(_localctx, 50, RULE_newinitializer);
int _la;
try {
setState(765);
switch (_input.LA(1)) {
case LeftParen:
enterOuterAlt(_localctx, 1);
{
setState(759);
match(LeftParen);
setState(761);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << False) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static_cast) | (1L << This))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Throw - 64)) | (1L << (True - 64)) | (1L << (Typeid - 64)) | (1L << (Typename - 64)) | (1L << (Unsigned - 64)) | (1L << (Void - 64)) | (1L << (Wchar - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (LeftBrace - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Doublecolon - 64)) | (1L << (Identifier - 64)) | (1L << (Integerliteral - 64)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(760);
expressionlist();
}
}
setState(763);
match(RightParen);
}
break;
case LeftBrace:
enterOuterAlt(_localctx, 2);
{
setState(764);
bracedinitlist();
}
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 DeleteexpressionContext extends ParserRuleContext {
public TerminalNode Delete() { return getToken(CPP14Parser.Delete, 0); }
public CastexpressionContext castexpression() {
return getRuleContext(CastexpressionContext.class,0);
}
public DeleteexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_deleteexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDeleteexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDeleteexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitDeleteexpression(this);
else return visitor.visitChildren(this);
}
}
public final DeleteexpressionContext deleteexpression() throws RecognitionException {
DeleteexpressionContext _localctx = new DeleteexpressionContext(_ctx, getState());
enterRule(_localctx, 52, RULE_deleteexpression);
int _la;
try {
setState(779);
switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(768);
_la = _input.LA(1);
if (_la==Doublecolon) {
{
setState(767);
match(Doublecolon);
}
}
setState(770);
match(Delete);
setState(771);
castexpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(773);
_la = _input.LA(1);
if (_la==Doublecolon) {
{
setState(772);
match(Doublecolon);
}
}
setState(775);
match(Delete);
setState(776);
match(LeftBracket);
setState(777);
match(RightBracket);
setState(778);
castexpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NoexceptexpressionContext extends ParserRuleContext {
public TerminalNode Noexcept() { return getToken(CPP14Parser.Noexcept, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public NoexceptexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_noexceptexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNoexceptexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNoexceptexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNoexceptexpression(this);
else return visitor.visitChildren(this);
}
}
public final NoexceptexpressionContext noexceptexpression() throws RecognitionException {
NoexceptexpressionContext _localctx = new NoexceptexpressionContext(_ctx, getState());
enterRule(_localctx, 54, RULE_noexceptexpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(781);
match(Noexcept);
setState(782);
match(LeftParen);
setState(783);
expression(0);
setState(784);
match(RightParen);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CastexpressionContext extends ParserRuleContext {
public UnaryexpressionContext unaryexpression() {
return getRuleContext(UnaryexpressionContext.class,0);
}
public TypeidContext typeid() {
return getRuleContext(TypeidContext.class,0);
}
public CastexpressionContext castexpression() {
return getRuleContext(CastexpressionContext.class,0);
}
public CastexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_castexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCastexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCastexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitCastexpression(this);
else return visitor.visitChildren(this);
}
}
public final CastexpressionContext castexpression() throws RecognitionException {
CastexpressionContext _localctx = new CastexpressionContext(_ctx, getState());
enterRule(_localctx, 56, RULE_castexpression);
try {
setState(792);
switch ( getInterpreter().adaptivePredict(_input,52,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(786);
unaryexpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(787);
match(LeftParen);
setState(788);
typeid();
setState(789);
match(RightParen);
setState(790);
castexpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PmexpressionContext extends ParserRuleContext {
public CastexpressionContext castexpression() {
return getRuleContext(CastexpressionContext.class,0);
}
public PmexpressionContext pmexpression() {
return getRuleContext(PmexpressionContext.class,0);
}
public PmexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pmexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPmexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPmexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitPmexpression(this);
else return visitor.visitChildren(this);
}
}
public final PmexpressionContext pmexpression() throws RecognitionException {
return pmexpression(0);
}
private PmexpressionContext pmexpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
PmexpressionContext _localctx = new PmexpressionContext(_ctx, _parentState);
PmexpressionContext _prevctx = _localctx;
int _startState = 58;
enterRecursionRule(_localctx, 58, RULE_pmexpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(795);
castexpression();
}
_ctx.stop = _input.LT(-1);
setState(805);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,54,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(803);
switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) {
case 1:
{
_localctx = new PmexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_pmexpression);
setState(797);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(798);
match(DotStar);
setState(799);
castexpression();
}
break;
case 2:
{
_localctx = new PmexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_pmexpression);
setState(800);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(801);
match(ArrowStar);
setState(802);
castexpression();
}
break;
}
}
}
setState(807);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,54,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class MultiplicativeexpressionContext extends ParserRuleContext {
public PmexpressionContext pmexpression() {
return getRuleContext(PmexpressionContext.class,0);
}
public MultiplicativeexpressionContext multiplicativeexpression() {
return getRuleContext(MultiplicativeexpressionContext.class,0);
}
public MultiplicativeexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiplicativeexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterMultiplicativeexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitMultiplicativeexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitMultiplicativeexpression(this);
else return visitor.visitChildren(this);
}
}
public final MultiplicativeexpressionContext multiplicativeexpression() throws RecognitionException {
return multiplicativeexpression(0);
}
private MultiplicativeexpressionContext multiplicativeexpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
MultiplicativeexpressionContext _localctx = new MultiplicativeexpressionContext(_ctx, _parentState);
MultiplicativeexpressionContext _prevctx = _localctx;
int _startState = 60;
enterRecursionRule(_localctx, 60, RULE_multiplicativeexpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(809);
pmexpression(0);
}
_ctx.stop = _input.LT(-1);
setState(822);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,56,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(820);
switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
case 1:
{
_localctx = new MultiplicativeexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeexpression);
setState(811);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(812);
match(Star);
setState(813);
pmexpression(0);
}
break;
case 2:
{
_localctx = new MultiplicativeexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeexpression);
setState(814);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(815);
match(Div);
setState(816);
pmexpression(0);
}
break;
case 3:
{
_localctx = new MultiplicativeexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_multiplicativeexpression);
setState(817);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(818);
match(Mod);
setState(819);
pmexpression(0);
}
break;
}
}
}
setState(824);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,56,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class AdditiveexpressionContext extends ParserRuleContext {
public MultiplicativeexpressionContext multiplicativeexpression() {
return getRuleContext(MultiplicativeexpressionContext.class,0);
}
public AdditiveexpressionContext additiveexpression() {
return getRuleContext(AdditiveexpressionContext.class,0);
}
public AdditiveexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_additiveexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAdditiveexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAdditiveexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAdditiveexpression(this);
else return visitor.visitChildren(this);
}
}
public final AdditiveexpressionContext additiveexpression() throws RecognitionException {
return additiveexpression(0);
}
private AdditiveexpressionContext additiveexpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
AdditiveexpressionContext _localctx = new AdditiveexpressionContext(_ctx, _parentState);
AdditiveexpressionContext _prevctx = _localctx;
int _startState = 62;
enterRecursionRule(_localctx, 62, RULE_additiveexpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(826);
multiplicativeexpression(0);
}
_ctx.stop = _input.LT(-1);
setState(836);
_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 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(834);
switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
case 1:
{
_localctx = new AdditiveexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_additiveexpression);
setState(828);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(829);
match(Plus);
setState(830);
multiplicativeexpression(0);
}
break;
case 2:
{
_localctx = new AdditiveexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_additiveexpression);
setState(831);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(832);
match(Minus);
setState(833);
multiplicativeexpression(0);
}
break;
}
}
}
setState(838);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,58,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ShiftexpressionContext extends ParserRuleContext {
public AdditiveexpressionContext additiveexpression() {
return getRuleContext(AdditiveexpressionContext.class,0);
}
public ShiftexpressionContext shiftexpression() {
return getRuleContext(ShiftexpressionContext.class,0);
}
public RightShiftContext rightShift() {
return getRuleContext(RightShiftContext.class,0);
}
public ShiftexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_shiftexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterShiftexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitShiftexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitShiftexpression(this);
else return visitor.visitChildren(this);
}
}
public final ShiftexpressionContext shiftexpression() throws RecognitionException {
return shiftexpression(0);
}
private ShiftexpressionContext shiftexpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ShiftexpressionContext _localctx = new ShiftexpressionContext(_ctx, _parentState);
ShiftexpressionContext _prevctx = _localctx;
int _startState = 64;
enterRecursionRule(_localctx, 64, RULE_shiftexpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(840);
additiveexpression(0);
}
_ctx.stop = _input.LT(-1);
setState(851);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(849);
switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
case 1:
{
_localctx = new ShiftexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_shiftexpression);
setState(842);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(843);
match(LeftShift);
setState(844);
additiveexpression(0);
}
break;
case 2:
{
_localctx = new ShiftexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_shiftexpression);
setState(845);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(846);
rightShift();
setState(847);
additiveexpression(0);
}
break;
}
}
}
setState(853);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,60,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class RelationalexpressionContext extends ParserRuleContext {
public ShiftexpressionContext shiftexpression() {
return getRuleContext(ShiftexpressionContext.class,0);
}
public RelationalexpressionContext relationalexpression() {
return getRuleContext(RelationalexpressionContext.class,0);
}
public RelationalexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relationalexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterRelationalexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitRelationalexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitRelationalexpression(this);
else return visitor.visitChildren(this);
}
}
public final RelationalexpressionContext relationalexpression() throws RecognitionException {
return relationalexpression(0);
}
private RelationalexpressionContext relationalexpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
RelationalexpressionContext _localctx = new RelationalexpressionContext(_ctx, _parentState);
RelationalexpressionContext _prevctx = _localctx;
int _startState = 66;
enterRecursionRule(_localctx, 66, RULE_relationalexpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(855);
shiftexpression(0);
}
_ctx.stop = _input.LT(-1);
setState(871);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,62,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(869);
switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) {
case 1:
{
_localctx = new RelationalexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_relationalexpression);
setState(857);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(858);
match(Less);
setState(859);
shiftexpression(0);
}
break;
case 2:
{
_localctx = new RelationalexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_relationalexpression);
setState(860);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(861);
match(Greater);
setState(862);
shiftexpression(0);
}
break;
case 3:
{
_localctx = new RelationalexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_relationalexpression);
setState(863);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(864);
match(LessEqual);
setState(865);
shiftexpression(0);
}
break;
case 4:
{
_localctx = new RelationalexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_relationalexpression);
setState(866);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(867);
match(GreaterEqual);
setState(868);
shiftexpression(0);
}
break;
}
}
}
setState(873);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,62,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class EqualityexpressionContext extends ParserRuleContext {
public RelationalexpressionContext relationalexpression() {
return getRuleContext(RelationalexpressionContext.class,0);
}
public EqualityexpressionContext equalityexpression() {
return getRuleContext(EqualityexpressionContext.class,0);
}
public EqualityexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_equalityexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEqualityexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEqualityexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitEqualityexpression(this);
else return visitor.visitChildren(this);
}
}
public final EqualityexpressionContext equalityexpression() throws RecognitionException {
return equalityexpression(0);
}
private EqualityexpressionContext equalityexpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
EqualityexpressionContext _localctx = new EqualityexpressionContext(_ctx, _parentState);
EqualityexpressionContext _prevctx = _localctx;
int _startState = 68;
enterRecursionRule(_localctx, 68, RULE_equalityexpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(875);
relationalexpression(0);
}
_ctx.stop = _input.LT(-1);
setState(885);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,64,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(883);
switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) {
case 1:
{
_localctx = new EqualityexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_equalityexpression);
setState(877);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(878);
match(Equal);
setState(879);
relationalexpression(0);
}
break;
case 2:
{
_localctx = new EqualityexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_equalityexpression);
setState(880);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(881);
match(NotEqual);
setState(882);
relationalexpression(0);
}
break;
}
}
}
setState(887);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,64,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class AndexpressionContext extends ParserRuleContext {
public EqualityexpressionContext equalityexpression() {
return getRuleContext(EqualityexpressionContext.class,0);
}
public AndexpressionContext andexpression() {
return getRuleContext(AndexpressionContext.class,0);
}
public AndexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_andexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAndexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAndexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAndexpression(this);
else return visitor.visitChildren(this);
}
}
public final AndexpressionContext andexpression() throws RecognitionException {
return andexpression(0);
}
private AndexpressionContext andexpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
AndexpressionContext _localctx = new AndexpressionContext(_ctx, _parentState);
AndexpressionContext _prevctx = _localctx;
int _startState = 70;
enterRecursionRule(_localctx, 70, RULE_andexpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(889);
equalityexpression(0);
}
_ctx.stop = _input.LT(-1);
setState(896);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,65,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new AndexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_andexpression);
setState(891);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(892);
match(And);
setState(893);
equalityexpression(0);
}
}
}
setState(898);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,65,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ExclusiveorexpressionContext extends ParserRuleContext {
public AndexpressionContext andexpression() {
return getRuleContext(AndexpressionContext.class,0);
}
public ExclusiveorexpressionContext exclusiveorexpression() {
return getRuleContext(ExclusiveorexpressionContext.class,0);
}
public ExclusiveorexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exclusiveorexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExclusiveorexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExclusiveorexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitExclusiveorexpression(this);
else return visitor.visitChildren(this);
}
}
public final ExclusiveorexpressionContext exclusiveorexpression() throws RecognitionException {
return exclusiveorexpression(0);
}
private ExclusiveorexpressionContext exclusiveorexpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExclusiveorexpressionContext _localctx = new ExclusiveorexpressionContext(_ctx, _parentState);
ExclusiveorexpressionContext _prevctx = _localctx;
int _startState = 72;
enterRecursionRule(_localctx, 72, RULE_exclusiveorexpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(900);
andexpression(0);
}
_ctx.stop = _input.LT(-1);
setState(907);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,66,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new ExclusiveorexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_exclusiveorexpression);
setState(902);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(903);
match(Caret);
setState(904);
andexpression(0);
}
}
}
setState(909);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,66,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class InclusiveorexpressionContext extends ParserRuleContext {
public ExclusiveorexpressionContext exclusiveorexpression() {
return getRuleContext(ExclusiveorexpressionContext.class,0);
}
public InclusiveorexpressionContext inclusiveorexpression() {
return getRuleContext(InclusiveorexpressionContext.class,0);
}
public InclusiveorexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inclusiveorexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInclusiveorexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInclusiveorexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitInclusiveorexpression(this);
else return visitor.visitChildren(this);
}
}
public final InclusiveorexpressionContext inclusiveorexpression() throws RecognitionException {
return inclusiveorexpression(0);
}
private InclusiveorexpressionContext inclusiveorexpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
InclusiveorexpressionContext _localctx = new InclusiveorexpressionContext(_ctx, _parentState);
InclusiveorexpressionContext _prevctx = _localctx;
int _startState = 74;
enterRecursionRule(_localctx, 74, RULE_inclusiveorexpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(911);
exclusiveorexpression(0);
}
_ctx.stop = _input.LT(-1);
setState(918);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,67,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new InclusiveorexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_inclusiveorexpression);
setState(913);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(914);
match(Or);
setState(915);
exclusiveorexpression(0);
}
}
}
setState(920);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,67,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class LogicalandexpressionContext extends ParserRuleContext {
public InclusiveorexpressionContext inclusiveorexpression() {
return getRuleContext(InclusiveorexpressionContext.class,0);
}
public LogicalandexpressionContext logicalandexpression() {
return getRuleContext(LogicalandexpressionContext.class,0);
}
public LogicalandexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_logicalandexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLogicalandexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLogicalandexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitLogicalandexpression(this);
else return visitor.visitChildren(this);
}
}
public final LogicalandexpressionContext logicalandexpression() throws RecognitionException {
return logicalandexpression(0);
}
private LogicalandexpressionContext logicalandexpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
LogicalandexpressionContext _localctx = new LogicalandexpressionContext(_ctx, _parentState);
LogicalandexpressionContext _prevctx = _localctx;
int _startState = 76;
enterRecursionRule(_localctx, 76, RULE_logicalandexpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(922);
inclusiveorexpression(0);
}
_ctx.stop = _input.LT(-1);
setState(929);
_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 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new LogicalandexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_logicalandexpression);
setState(924);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(925);
match(AndAnd);
setState(926);
inclusiveorexpression(0);
}
}
}
setState(931);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,68,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class LogicalorexpressionContext extends ParserRuleContext {
public LogicalandexpressionContext logicalandexpression() {
return getRuleContext(LogicalandexpressionContext.class,0);
}
public LogicalorexpressionContext logicalorexpression() {
return getRuleContext(LogicalorexpressionContext.class,0);
}
public LogicalorexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_logicalorexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLogicalorexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLogicalorexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitLogicalorexpression(this);
else return visitor.visitChildren(this);
}
}
public final LogicalorexpressionContext logicalorexpression() throws RecognitionException {
return logicalorexpression(0);
}
private LogicalorexpressionContext logicalorexpression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
LogicalorexpressionContext _localctx = new LogicalorexpressionContext(_ctx, _parentState);
LogicalorexpressionContext _prevctx = _localctx;
int _startState = 78;
enterRecursionRule(_localctx, 78, RULE_logicalorexpression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(933);
logicalandexpression(0);
}
_ctx.stop = _input.LT(-1);
setState(940);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,69,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new LogicalorexpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_logicalorexpression);
setState(935);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(936);
match(OrOr);
setState(937);
logicalandexpression(0);
}
}
}
setState(942);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,69,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ConditionalexpressionContext extends ParserRuleContext {
public LogicalorexpressionContext logicalorexpression() {
return getRuleContext(LogicalorexpressionContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public AssignmentexpressionContext assignmentexpression() {
return getRuleContext(AssignmentexpressionContext.class,0);
}
public ConditionalexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditionalexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterConditionalexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitConditionalexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitConditionalexpression(this);
else return visitor.visitChildren(this);
}
}
public final ConditionalexpressionContext conditionalexpression() throws RecognitionException {
ConditionalexpressionContext _localctx = new ConditionalexpressionContext(_ctx, getState());
enterRule(_localctx, 80, RULE_conditionalexpression);
try {
setState(950);
switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(943);
logicalorexpression(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(944);
logicalorexpression(0);
setState(945);
match(Question);
setState(946);
expression(0);
setState(947);
match(Colon);
setState(948);
assignmentexpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AssignmentexpressionContext extends ParserRuleContext {
public ConditionalexpressionContext conditionalexpression() {
return getRuleContext(ConditionalexpressionContext.class,0);
}
public LogicalorexpressionContext logicalorexpression() {
return getRuleContext(LogicalorexpressionContext.class,0);
}
public AssignmentoperatorContext assignmentoperator() {
return getRuleContext(AssignmentoperatorContext.class,0);
}
public InitializerclauseContext initializerclause() {
return getRuleContext(InitializerclauseContext.class,0);
}
public ThrowexpressionContext throwexpression() {
return getRuleContext(ThrowexpressionContext.class,0);
}
public AssignmentexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignmentexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAssignmentexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAssignmentexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAssignmentexpression(this);
else return visitor.visitChildren(this);
}
}
public final AssignmentexpressionContext assignmentexpression() throws RecognitionException {
AssignmentexpressionContext _localctx = new AssignmentexpressionContext(_ctx, getState());
enterRule(_localctx, 82, RULE_assignmentexpression);
try {
setState(958);
switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(952);
conditionalexpression();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(953);
logicalorexpression(0);
setState(954);
assignmentoperator();
setState(955);
initializerclause();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(957);
throwexpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AssignmentoperatorContext extends ParserRuleContext {
public RightShiftAssignContext rightShiftAssign() {
return getRuleContext(RightShiftAssignContext.class,0);
}
public AssignmentoperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignmentoperator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAssignmentoperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAssignmentoperator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAssignmentoperator(this);
else return visitor.visitChildren(this);
}
}
public final AssignmentoperatorContext assignmentoperator() throws RecognitionException {
AssignmentoperatorContext _localctx = new AssignmentoperatorContext(_ctx, getState());
enterRule(_localctx, 84, RULE_assignmentoperator);
try {
setState(971);
switch (_input.LA(1)) {
case Assign:
enterOuterAlt(_localctx, 1);
{
setState(960);
match(Assign);
}
break;
case StarAssign:
enterOuterAlt(_localctx, 2);
{
setState(961);
match(StarAssign);
}
break;
case DivAssign:
enterOuterAlt(_localctx, 3);
{
setState(962);
match(DivAssign);
}
break;
case ModAssign:
enterOuterAlt(_localctx, 4);
{
setState(963);
match(ModAssign);
}
break;
case PlusAssign:
enterOuterAlt(_localctx, 5);
{
setState(964);
match(PlusAssign);
}
break;
case MinusAssign:
enterOuterAlt(_localctx, 6);
{
setState(965);
match(MinusAssign);
}
break;
case Greater:
enterOuterAlt(_localctx, 7);
{
setState(966);
rightShiftAssign();
}
break;
case LeftShiftAssign:
enterOuterAlt(_localctx, 8);
{
setState(967);
match(LeftShiftAssign);
}
break;
case AndAssign:
enterOuterAlt(_localctx, 9);
{
setState(968);
match(AndAssign);
}
break;
case XorAssign:
enterOuterAlt(_localctx, 10);
{
setState(969);
match(XorAssign);
}
break;
case OrAssign:
enterOuterAlt(_localctx, 11);
{
setState(970);
match(OrAssign);
}
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 ExpressionContext extends ParserRuleContext {
public AssignmentexpressionContext assignmentexpression() {
return getRuleContext(AssignmentexpressionContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
return expression(0);
}
private ExpressionContext expression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
ExpressionContext _prevctx = _localctx;
int _startState = 86;
enterRecursionRule(_localctx, 86, RULE_expression, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(974);
assignmentexpression();
}
_ctx.stop = _input.LT(-1);
setState(981);
_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 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new ExpressionContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_expression);
setState(976);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(977);
match(Comma);
setState(978);
assignmentexpression();
}
}
}
setState(983);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,73,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ConstantexpressionContext extends ParserRuleContext {
public ConditionalexpressionContext conditionalexpression() {
return getRuleContext(ConditionalexpressionContext.class,0);
}
public ConstantexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constantexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterConstantexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitConstantexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitConstantexpression(this);
else return visitor.visitChildren(this);
}
}
public final ConstantexpressionContext constantexpression() throws RecognitionException {
ConstantexpressionContext _localctx = new ConstantexpressionContext(_ctx, getState());
enterRule(_localctx, 88, RULE_constantexpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(984);
conditionalexpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementContext extends ParserRuleContext {
public LabeledstatementContext labeledstatement() {
return getRuleContext(LabeledstatementContext.class,0);
}
public ExpressionstatementContext expressionstatement() {
return getRuleContext(ExpressionstatementContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public CompoundstatementContext compoundstatement() {
return getRuleContext(CompoundstatementContext.class,0);
}
public SelectionstatementContext selectionstatement() {
return getRuleContext(SelectionstatementContext.class,0);
}
public IterationstatementContext iterationstatement() {
return getRuleContext(IterationstatementContext.class,0);
}
public JumpstatementContext jumpstatement() {
return getRuleContext(JumpstatementContext.class,0);
}
public DeclarationstatementContext declarationstatement() {
return getRuleContext(DeclarationstatementContext.class,0);
}
public TryblockContext tryblock() {
return getRuleContext(TryblockContext.class,0);
}
public StatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitStatement(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 90, RULE_statement);
int _la;
try {
setState(1012);
switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(986);
labeledstatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(988);
switch ( getInterpreter().adaptivePredict(_input,74,_ctx) ) {
case 1:
{
setState(987);
attributespecifierseq(0);
}
break;
}
setState(990);
expressionstatement();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(992);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(991);
attributespecifierseq(0);
}
}
setState(994);
compoundstatement();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(996);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(995);
attributespecifierseq(0);
}
}
setState(998);
selectionstatement();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1000);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(999);
attributespecifierseq(0);
}
}
setState(1002);
iterationstatement();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1004);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1003);
attributespecifierseq(0);
}
}
setState(1006);
jumpstatement();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1007);
declarationstatement();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1009);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1008);
attributespecifierseq(0);
}
}
setState(1011);
tryblock();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LabeledstatementContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public TerminalNode Case() { return getToken(CPP14Parser.Case, 0); }
public ConstantexpressionContext constantexpression() {
return getRuleContext(ConstantexpressionContext.class,0);
}
public TerminalNode Default() { return getToken(CPP14Parser.Default, 0); }
public LabeledstatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_labeledstatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLabeledstatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLabeledstatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitLabeledstatement(this);
else return visitor.visitChildren(this);
}
}
public final LabeledstatementContext labeledstatement() throws RecognitionException {
LabeledstatementContext _localctx = new LabeledstatementContext(_ctx, getState());
enterRule(_localctx, 92, RULE_labeledstatement);
int _la;
try {
setState(1034);
switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1015);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1014);
attributespecifierseq(0);
}
}
setState(1017);
match(Identifier);
setState(1018);
match(Colon);
setState(1019);
statement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1021);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1020);
attributespecifierseq(0);
}
}
setState(1023);
match(Case);
setState(1024);
constantexpression();
setState(1025);
match(Colon);
setState(1026);
statement();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1029);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1028);
attributespecifierseq(0);
}
}
setState(1031);
match(Default);
setState(1032);
match(Colon);
setState(1033);
statement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionstatementContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ExpressionstatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expressionstatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExpressionstatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExpressionstatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitExpressionstatement(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionstatementContext expressionstatement() throws RecognitionException {
ExpressionstatementContext _localctx = new ExpressionstatementContext(_ctx, getState());
enterRule(_localctx, 94, RULE_expressionstatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1037);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << False) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static_cast) | (1L << This))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Throw - 64)) | (1L << (True - 64)) | (1L << (Typeid - 64)) | (1L << (Typename - 64)) | (1L << (Unsigned - 64)) | (1L << (Void - 64)) | (1L << (Wchar - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Doublecolon - 64)) | (1L << (Identifier - 64)) | (1L << (Integerliteral - 64)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(1036);
expression(0);
}
}
setState(1039);
match(Semi);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CompoundstatementContext extends ParserRuleContext {
public StatementseqContext statementseq() {
return getRuleContext(StatementseqContext.class,0);
}
public CompoundstatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_compoundstatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCompoundstatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCompoundstatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitCompoundstatement(this);
else return visitor.visitChildren(this);
}
}
public final CompoundstatementContext compoundstatement() throws RecognitionException {
CompoundstatementContext _localctx = new CompoundstatementContext(_ctx, getState());
enterRule(_localctx, 96, RULE_compoundstatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1041);
match(LeftBrace);
setState(1043);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignas) | (1L << Alignof) | (1L << Asm) | (1L << Auto) | (1L << Bool) | (1L << Break) | (1L << Case) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Const_cast) | (1L << Continue) | (1L << Decltype) | (1L << Default) | (1L << Delete) | (1L << Do) | (1L << Double) | (1L << Dynamic_cast) | (1L << Enum) | (1L << Explicit) | (1L << Extern) | (1L << False) | (1L << Float) | (1L << For) | (1L << Friend) | (1L << Goto) | (1L << If) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << Namespace) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Register) | (1L << Reinterpret_cast) | (1L << Return) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static) | (1L << Static_assert) | (1L << Static_cast) | (1L << Struct) | (1L << Switch) | (1L << This) | (1L << Thread_local))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Throw - 64)) | (1L << (True - 64)) | (1L << (Try - 64)) | (1L << (Typedef - 64)) | (1L << (Typeid - 64)) | (1L << (Typename - 64)) | (1L << (Union - 64)) | (1L << (Unsigned - 64)) | (1L << (Using - 64)) | (1L << (Virtual - 64)) | (1L << (Void - 64)) | (1L << (Volatile - 64)) | (1L << (Wchar - 64)) | (1L << (While - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (LeftBrace - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (AndAnd - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Doublecolon - 64)) | (1L << (Semi - 64)) | (1L << (Ellipsis - 64)) | (1L << (Identifier - 64)) | (1L << (Integerliteral - 64)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(1042);
statementseq(0);
}
}
setState(1045);
match(RightBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StatementseqContext extends ParserRuleContext {
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public StatementseqContext statementseq() {
return getRuleContext(StatementseqContext.class,0);
}
public StatementseqContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_statementseq; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterStatementseq(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitStatementseq(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitStatementseq(this);
else return visitor.visitChildren(this);
}
}
public final StatementseqContext statementseq() throws RecognitionException {
return statementseq(0);
}
private StatementseqContext statementseq(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
StatementseqContext _localctx = new StatementseqContext(_ctx, _parentState);
StatementseqContext _prevctx = _localctx;
int _startState = 98;
enterRecursionRule(_localctx, 98, RULE_statementseq, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1048);
statement();
}
_ctx.stop = _input.LT(-1);
setState(1054);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,87,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new StatementseqContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_statementseq);
setState(1050);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1051);
statement();
}
}
}
setState(1056);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,87,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class SelectionstatementContext extends ParserRuleContext {
public TerminalNode If() { return getToken(CPP14Parser.If, 0); }
public ConditionContext condition() {
return getRuleContext(ConditionContext.class,0);
}
public List statement() {
return getRuleContexts(StatementContext.class);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public TerminalNode Else() { return getToken(CPP14Parser.Else, 0); }
public TerminalNode Switch() { return getToken(CPP14Parser.Switch, 0); }
public SelectionstatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectionstatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterSelectionstatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitSelectionstatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitSelectionstatement(this);
else return visitor.visitChildren(this);
}
}
public final SelectionstatementContext selectionstatement() throws RecognitionException {
SelectionstatementContext _localctx = new SelectionstatementContext(_ctx, getState());
enterRule(_localctx, 100, RULE_selectionstatement);
try {
setState(1077);
switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1057);
match(If);
setState(1058);
match(LeftParen);
setState(1059);
condition();
setState(1060);
match(RightParen);
setState(1061);
statement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1063);
match(If);
setState(1064);
match(LeftParen);
setState(1065);
condition();
setState(1066);
match(RightParen);
setState(1067);
statement();
setState(1068);
match(Else);
setState(1069);
statement();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1071);
match(Switch);
setState(1072);
match(LeftParen);
setState(1073);
condition();
setState(1074);
match(RightParen);
setState(1075);
statement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConditionContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public DeclspecifierseqContext declspecifierseq() {
return getRuleContext(DeclspecifierseqContext.class,0);
}
public DeclaratorContext declarator() {
return getRuleContext(DeclaratorContext.class,0);
}
public InitializerclauseContext initializerclause() {
return getRuleContext(InitializerclauseContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public BracedinitlistContext bracedinitlist() {
return getRuleContext(BracedinitlistContext.class,0);
}
public ConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_condition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCondition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCondition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitCondition(this);
else return visitor.visitChildren(this);
}
}
public final ConditionContext condition() throws RecognitionException {
ConditionContext _localctx = new ConditionContext(_ctx, getState());
enterRule(_localctx, 102, RULE_condition);
int _la;
try {
setState(1095);
switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1079);
expression(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1081);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1080);
attributespecifierseq(0);
}
}
setState(1083);
declspecifierseq();
setState(1084);
declarator();
setState(1085);
match(Assign);
setState(1086);
initializerclause();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1089);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1088);
attributespecifierseq(0);
}
}
setState(1091);
declspecifierseq();
setState(1092);
declarator();
setState(1093);
bracedinitlist();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IterationstatementContext extends ParserRuleContext {
public TerminalNode While() { return getToken(CPP14Parser.While, 0); }
public ConditionContext condition() {
return getRuleContext(ConditionContext.class,0);
}
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public TerminalNode Do() { return getToken(CPP14Parser.Do, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode For() { return getToken(CPP14Parser.For, 0); }
public ForinitstatementContext forinitstatement() {
return getRuleContext(ForinitstatementContext.class,0);
}
public ForrangedeclarationContext forrangedeclaration() {
return getRuleContext(ForrangedeclarationContext.class,0);
}
public ForrangeinitializerContext forrangeinitializer() {
return getRuleContext(ForrangeinitializerContext.class,0);
}
public IterationstatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_iterationstatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterIterationstatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitIterationstatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitIterationstatement(this);
else return visitor.visitChildren(this);
}
}
public final IterationstatementContext iterationstatement() throws RecognitionException {
IterationstatementContext _localctx = new IterationstatementContext(_ctx, getState());
enterRule(_localctx, 104, RULE_iterationstatement);
int _la;
try {
setState(1132);
switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1097);
match(While);
setState(1098);
match(LeftParen);
setState(1099);
condition();
setState(1100);
match(RightParen);
setState(1101);
statement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1103);
match(Do);
setState(1104);
statement();
setState(1105);
match(While);
setState(1106);
match(LeftParen);
setState(1107);
expression(0);
setState(1108);
match(RightParen);
setState(1109);
match(Semi);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1111);
match(For);
setState(1112);
match(LeftParen);
setState(1113);
forinitstatement();
setState(1115);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignas) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Enum) | (1L << Explicit) | (1L << Extern) | (1L << False) | (1L << Float) | (1L << Friend) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Register) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static) | (1L << Static_cast) | (1L << Struct) | (1L << This) | (1L << Thread_local))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Throw - 64)) | (1L << (True - 64)) | (1L << (Typedef - 64)) | (1L << (Typeid - 64)) | (1L << (Typename - 64)) | (1L << (Union - 64)) | (1L << (Unsigned - 64)) | (1L << (Virtual - 64)) | (1L << (Void - 64)) | (1L << (Volatile - 64)) | (1L << (Wchar - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Doublecolon - 64)) | (1L << (Identifier - 64)) | (1L << (Integerliteral - 64)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(1114);
condition();
}
}
setState(1117);
match(Semi);
setState(1119);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << False) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static_cast) | (1L << This))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Throw - 64)) | (1L << (True - 64)) | (1L << (Typeid - 64)) | (1L << (Typename - 64)) | (1L << (Unsigned - 64)) | (1L << (Void - 64)) | (1L << (Wchar - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Doublecolon - 64)) | (1L << (Identifier - 64)) | (1L << (Integerliteral - 64)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(1118);
expression(0);
}
}
setState(1121);
match(RightParen);
setState(1122);
statement();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1124);
match(For);
setState(1125);
match(LeftParen);
setState(1126);
forrangedeclaration();
setState(1127);
match(Colon);
setState(1128);
forrangeinitializer();
setState(1129);
match(RightParen);
setState(1130);
statement();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForinitstatementContext extends ParserRuleContext {
public ExpressionstatementContext expressionstatement() {
return getRuleContext(ExpressionstatementContext.class,0);
}
public SimpledeclarationContext simpledeclaration() {
return getRuleContext(SimpledeclarationContext.class,0);
}
public ForinitstatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forinitstatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterForinitstatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitForinitstatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitForinitstatement(this);
else return visitor.visitChildren(this);
}
}
public final ForinitstatementContext forinitstatement() throws RecognitionException {
ForinitstatementContext _localctx = new ForinitstatementContext(_ctx, getState());
enterRule(_localctx, 106, RULE_forinitstatement);
try {
setState(1136);
switch ( getInterpreter().adaptivePredict(_input,95,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1134);
expressionstatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1135);
simpledeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForrangedeclarationContext extends ParserRuleContext {
public DeclspecifierseqContext declspecifierseq() {
return getRuleContext(DeclspecifierseqContext.class,0);
}
public DeclaratorContext declarator() {
return getRuleContext(DeclaratorContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public ForrangedeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forrangedeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterForrangedeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitForrangedeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitForrangedeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ForrangedeclarationContext forrangedeclaration() throws RecognitionException {
ForrangedeclarationContext _localctx = new ForrangedeclarationContext(_ctx, getState());
enterRule(_localctx, 108, RULE_forrangedeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1139);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1138);
attributespecifierseq(0);
}
}
setState(1141);
declspecifierseq();
setState(1142);
declarator();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForrangeinitializerContext extends ParserRuleContext {
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public BracedinitlistContext bracedinitlist() {
return getRuleContext(BracedinitlistContext.class,0);
}
public ForrangeinitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forrangeinitializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterForrangeinitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitForrangeinitializer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitForrangeinitializer(this);
else return visitor.visitChildren(this);
}
}
public final ForrangeinitializerContext forrangeinitializer() throws RecognitionException {
ForrangeinitializerContext _localctx = new ForrangeinitializerContext(_ctx, getState());
enterRule(_localctx, 110, RULE_forrangeinitializer);
try {
setState(1146);
switch (_input.LA(1)) {
case Alignof:
case Auto:
case Bool:
case Char:
case Char16:
case Char32:
case Const_cast:
case Decltype:
case Delete:
case Double:
case Dynamic_cast:
case False:
case Float:
case Int:
case Long:
case New:
case Noexcept:
case Nullptr:
case Operator:
case Reinterpret_cast:
case Short:
case Signed:
case Sizeof:
case Static_cast:
case This:
case Throw:
case True:
case Typeid:
case Typename:
case Unsigned:
case Void:
case Wchar:
case LeftParen:
case LeftBracket:
case Plus:
case Minus:
case Star:
case And:
case Or:
case Tilde:
case Not:
case PlusPlus:
case MinusMinus:
case Doublecolon:
case Identifier:
case Integerliteral:
case Characterliteral:
case Floatingliteral:
case Stringliteral:
case Userdefinedintegerliteral:
case Userdefinedfloatingliteral:
case Userdefinedstringliteral:
case Userdefinedcharacterliteral:
enterOuterAlt(_localctx, 1);
{
setState(1144);
expression(0);
}
break;
case LeftBrace:
enterOuterAlt(_localctx, 2);
{
setState(1145);
bracedinitlist();
}
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 JumpstatementContext extends ParserRuleContext {
public TerminalNode Break() { return getToken(CPP14Parser.Break, 0); }
public TerminalNode Continue() { return getToken(CPP14Parser.Continue, 0); }
public TerminalNode Return() { return getToken(CPP14Parser.Return, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public BracedinitlistContext bracedinitlist() {
return getRuleContext(BracedinitlistContext.class,0);
}
public TerminalNode Goto() { return getToken(CPP14Parser.Goto, 0); }
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public JumpstatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jumpstatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterJumpstatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitJumpstatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitJumpstatement(this);
else return visitor.visitChildren(this);
}
}
public final JumpstatementContext jumpstatement() throws RecognitionException {
JumpstatementContext _localctx = new JumpstatementContext(_ctx, getState());
enterRule(_localctx, 112, RULE_jumpstatement);
int _la;
try {
setState(1164);
switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1148);
match(Break);
setState(1149);
match(Semi);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1150);
match(Continue);
setState(1151);
match(Semi);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1152);
match(Return);
setState(1154);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << False) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static_cast) | (1L << This))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Throw - 64)) | (1L << (True - 64)) | (1L << (Typeid - 64)) | (1L << (Typename - 64)) | (1L << (Unsigned - 64)) | (1L << (Void - 64)) | (1L << (Wchar - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Doublecolon - 64)) | (1L << (Identifier - 64)) | (1L << (Integerliteral - 64)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(1153);
expression(0);
}
}
setState(1156);
match(Semi);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1157);
match(Return);
setState(1158);
bracedinitlist();
setState(1159);
match(Semi);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1161);
match(Goto);
setState(1162);
match(Identifier);
setState(1163);
match(Semi);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclarationstatementContext extends ParserRuleContext {
public BlockdeclarationContext blockdeclaration() {
return getRuleContext(BlockdeclarationContext.class,0);
}
public DeclarationstatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declarationstatement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDeclarationstatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDeclarationstatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitDeclarationstatement(this);
else return visitor.visitChildren(this);
}
}
public final DeclarationstatementContext declarationstatement() throws RecognitionException {
DeclarationstatementContext _localctx = new DeclarationstatementContext(_ctx, getState());
enterRule(_localctx, 114, RULE_declarationstatement);
try {
enterOuterAlt(_localctx, 1);
{
setState(1166);
blockdeclaration();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclarationseqContext extends ParserRuleContext {
public DeclarationContext declaration() {
return getRuleContext(DeclarationContext.class,0);
}
public DeclarationseqContext declarationseq() {
return getRuleContext(DeclarationseqContext.class,0);
}
public DeclarationseqContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declarationseq; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDeclarationseq(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDeclarationseq(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitDeclarationseq(this);
else return visitor.visitChildren(this);
}
}
public final DeclarationseqContext declarationseq() throws RecognitionException {
return declarationseq(0);
}
private DeclarationseqContext declarationseq(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
DeclarationseqContext _localctx = new DeclarationseqContext(_ctx, _parentState);
DeclarationseqContext _prevctx = _localctx;
int _startState = 116;
enterRecursionRule(_localctx, 116, RULE_declarationseq, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1169);
declaration();
}
_ctx.stop = _input.LT(-1);
setState(1175);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,100,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new DeclarationseqContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_declarationseq);
setState(1171);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1172);
declaration();
}
}
}
setState(1177);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,100,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class DeclarationContext extends ParserRuleContext {
public BlockdeclarationContext blockdeclaration() {
return getRuleContext(BlockdeclarationContext.class,0);
}
public FunctiondefinitionContext functiondefinition() {
return getRuleContext(FunctiondefinitionContext.class,0);
}
public TemplatedeclarationContext templatedeclaration() {
return getRuleContext(TemplatedeclarationContext.class,0);
}
public ExplicitinstantiationContext explicitinstantiation() {
return getRuleContext(ExplicitinstantiationContext.class,0);
}
public ExplicitspecializationContext explicitspecialization() {
return getRuleContext(ExplicitspecializationContext.class,0);
}
public LinkagespecificationContext linkagespecification() {
return getRuleContext(LinkagespecificationContext.class,0);
}
public NamespacedefinitionContext namespacedefinition() {
return getRuleContext(NamespacedefinitionContext.class,0);
}
public EmptydeclarationContext emptydeclaration() {
return getRuleContext(EmptydeclarationContext.class,0);
}
public AttributedeclarationContext attributedeclaration() {
return getRuleContext(AttributedeclarationContext.class,0);
}
public DeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final DeclarationContext declaration() throws RecognitionException {
DeclarationContext _localctx = new DeclarationContext(_ctx, getState());
enterRule(_localctx, 118, RULE_declaration);
try {
setState(1187);
switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1178);
blockdeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1179);
functiondefinition();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1180);
templatedeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1181);
explicitinstantiation();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1182);
explicitspecialization();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1183);
linkagespecification();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1184);
namespacedefinition();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1185);
emptydeclaration();
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(1186);
attributedeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BlockdeclarationContext extends ParserRuleContext {
public SimpledeclarationContext simpledeclaration() {
return getRuleContext(SimpledeclarationContext.class,0);
}
public AsmdefinitionContext asmdefinition() {
return getRuleContext(AsmdefinitionContext.class,0);
}
public NamespacealiasdefinitionContext namespacealiasdefinition() {
return getRuleContext(NamespacealiasdefinitionContext.class,0);
}
public UsingdeclarationContext usingdeclaration() {
return getRuleContext(UsingdeclarationContext.class,0);
}
public UsingdirectiveContext usingdirective() {
return getRuleContext(UsingdirectiveContext.class,0);
}
public Static_assertdeclarationContext static_assertdeclaration() {
return getRuleContext(Static_assertdeclarationContext.class,0);
}
public AliasdeclarationContext aliasdeclaration() {
return getRuleContext(AliasdeclarationContext.class,0);
}
public OpaqueenumdeclarationContext opaqueenumdeclaration() {
return getRuleContext(OpaqueenumdeclarationContext.class,0);
}
public BlockdeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_blockdeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBlockdeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBlockdeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitBlockdeclaration(this);
else return visitor.visitChildren(this);
}
}
public final BlockdeclarationContext blockdeclaration() throws RecognitionException {
BlockdeclarationContext _localctx = new BlockdeclarationContext(_ctx, getState());
enterRule(_localctx, 120, RULE_blockdeclaration);
try {
setState(1197);
switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1189);
simpledeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1190);
asmdefinition();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1191);
namespacealiasdefinition();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1192);
usingdeclaration();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1193);
usingdirective();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1194);
static_assertdeclaration();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1195);
aliasdeclaration();
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1196);
opaqueenumdeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AliasdeclarationContext extends ParserRuleContext {
public TerminalNode Using() { return getToken(CPP14Parser.Using, 0); }
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public TypeidContext typeid() {
return getRuleContext(TypeidContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public AliasdeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_aliasdeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAliasdeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAliasdeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAliasdeclaration(this);
else return visitor.visitChildren(this);
}
}
public final AliasdeclarationContext aliasdeclaration() throws RecognitionException {
AliasdeclarationContext _localctx = new AliasdeclarationContext(_ctx, getState());
enterRule(_localctx, 122, RULE_aliasdeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1199);
match(Using);
setState(1200);
match(Identifier);
setState(1202);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1201);
attributespecifierseq(0);
}
}
setState(1204);
match(Assign);
setState(1205);
typeid();
setState(1206);
match(Semi);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpledeclarationContext extends ParserRuleContext {
public DeclspecifierseqContext declspecifierseq() {
return getRuleContext(DeclspecifierseqContext.class,0);
}
public InitdeclaratorlistContext initdeclaratorlist() {
return getRuleContext(InitdeclaratorlistContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public SimpledeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpledeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterSimpledeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitSimpledeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitSimpledeclaration(this);
else return visitor.visitChildren(this);
}
}
public final SimpledeclarationContext simpledeclaration() throws RecognitionException {
SimpledeclarationContext _localctx = new SimpledeclarationContext(_ctx, getState());
enterRule(_localctx, 124, RULE_simpledeclaration);
int _la;
try {
setState(1222);
switch (_input.LA(1)) {
case Auto:
case Bool:
case Char:
case Char16:
case Char32:
case Class:
case Const:
case Constexpr:
case Decltype:
case Double:
case Enum:
case Explicit:
case Extern:
case Float:
case Friend:
case Inline:
case Int:
case Long:
case Mutable:
case Operator:
case Register:
case Short:
case Signed:
case Static:
case Struct:
case Thread_local:
case Typedef:
case Typename:
case Union:
case Unsigned:
case Virtual:
case Void:
case Volatile:
case Wchar:
case LeftParen:
case Star:
case And:
case Tilde:
case AndAnd:
case Doublecolon:
case Semi:
case Ellipsis:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(1209);
switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) {
case 1:
{
setState(1208);
declspecifierseq();
}
break;
}
setState(1212);
_la = _input.LA(1);
if (_la==Decltype || _la==Operator || ((((_la - 78)) & ~0x3f) == 0 && ((1L << (_la - 78)) & ((1L << (LeftParen - 78)) | (1L << (Star - 78)) | (1L << (And - 78)) | (1L << (Tilde - 78)) | (1L << (AndAnd - 78)) | (1L << (Doublecolon - 78)) | (1L << (Ellipsis - 78)) | (1L << (Identifier - 78)))) != 0)) {
{
setState(1211);
initdeclaratorlist(0);
}
}
setState(1214);
match(Semi);
}
break;
case Alignas:
case LeftBracket:
enterOuterAlt(_localctx, 2);
{
setState(1215);
attributespecifierseq(0);
setState(1217);
switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) {
case 1:
{
setState(1216);
declspecifierseq();
}
break;
}
setState(1219);
initdeclaratorlist(0);
setState(1220);
match(Semi);
}
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 Static_assertdeclarationContext extends ParserRuleContext {
public TerminalNode Static_assert() { return getToken(CPP14Parser.Static_assert, 0); }
public ConstantexpressionContext constantexpression() {
return getRuleContext(ConstantexpressionContext.class,0);
}
public TerminalNode Stringliteral() { return getToken(CPP14Parser.Stringliteral, 0); }
public Static_assertdeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_static_assertdeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterStatic_assertdeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitStatic_assertdeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitStatic_assertdeclaration(this);
else return visitor.visitChildren(this);
}
}
public final Static_assertdeclarationContext static_assertdeclaration() throws RecognitionException {
Static_assertdeclarationContext _localctx = new Static_assertdeclarationContext(_ctx, getState());
enterRule(_localctx, 126, RULE_static_assertdeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(1224);
match(Static_assert);
setState(1225);
match(LeftParen);
setState(1226);
constantexpression();
setState(1227);
match(Comma);
setState(1228);
match(Stringliteral);
setState(1229);
match(RightParen);
setState(1230);
match(Semi);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EmptydeclarationContext extends ParserRuleContext {
public EmptydeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_emptydeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEmptydeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEmptydeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitEmptydeclaration(this);
else return visitor.visitChildren(this);
}
}
public final EmptydeclarationContext emptydeclaration() throws RecognitionException {
EmptydeclarationContext _localctx = new EmptydeclarationContext(_ctx, getState());
enterRule(_localctx, 128, RULE_emptydeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(1232);
match(Semi);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributedeclarationContext extends ParserRuleContext {
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public AttributedeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributedeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttributedeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttributedeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAttributedeclaration(this);
else return visitor.visitChildren(this);
}
}
public final AttributedeclarationContext attributedeclaration() throws RecognitionException {
AttributedeclarationContext _localctx = new AttributedeclarationContext(_ctx, getState());
enterRule(_localctx, 130, RULE_attributedeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(1234);
attributespecifierseq(0);
setState(1235);
match(Semi);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclspecifierContext extends ParserRuleContext {
public StorageclassspecifierContext storageclassspecifier() {
return getRuleContext(StorageclassspecifierContext.class,0);
}
public TypespecifierContext typespecifier() {
return getRuleContext(TypespecifierContext.class,0);
}
public FunctionspecifierContext functionspecifier() {
return getRuleContext(FunctionspecifierContext.class,0);
}
public TerminalNode Friend() { return getToken(CPP14Parser.Friend, 0); }
public TerminalNode Typedef() { return getToken(CPP14Parser.Typedef, 0); }
public TerminalNode Constexpr() { return getToken(CPP14Parser.Constexpr, 0); }
public DeclspecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declspecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDeclspecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDeclspecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitDeclspecifier(this);
else return visitor.visitChildren(this);
}
}
public final DeclspecifierContext declspecifier() throws RecognitionException {
DeclspecifierContext _localctx = new DeclspecifierContext(_ctx, getState());
enterRule(_localctx, 132, RULE_declspecifier);
try {
setState(1243);
switch (_input.LA(1)) {
case Extern:
case Mutable:
case Register:
case Static:
case Thread_local:
enterOuterAlt(_localctx, 1);
{
setState(1237);
storageclassspecifier();
}
break;
case Auto:
case Bool:
case Char:
case Char16:
case Char32:
case Class:
case Const:
case Decltype:
case Double:
case Enum:
case Float:
case Int:
case Long:
case Short:
case Signed:
case Struct:
case Typename:
case Union:
case Unsigned:
case Void:
case Volatile:
case Wchar:
case Doublecolon:
case Identifier:
enterOuterAlt(_localctx, 2);
{
setState(1238);
typespecifier();
}
break;
case Explicit:
case Inline:
case Virtual:
enterOuterAlt(_localctx, 3);
{
setState(1239);
functionspecifier();
}
break;
case Friend:
enterOuterAlt(_localctx, 4);
{
setState(1240);
match(Friend);
}
break;
case Typedef:
enterOuterAlt(_localctx, 5);
{
setState(1241);
match(Typedef);
}
break;
case Constexpr:
enterOuterAlt(_localctx, 6);
{
setState(1242);
match(Constexpr);
}
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 DeclspecifierseqContext extends ParserRuleContext {
public DeclspecifierContext declspecifier() {
return getRuleContext(DeclspecifierContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public DeclspecifierseqContext declspecifierseq() {
return getRuleContext(DeclspecifierseqContext.class,0);
}
public DeclspecifierseqContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declspecifierseq; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDeclspecifierseq(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDeclspecifierseq(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitDeclspecifierseq(this);
else return visitor.visitChildren(this);
}
}
public final DeclspecifierseqContext declspecifierseq() throws RecognitionException {
DeclspecifierseqContext _localctx = new DeclspecifierseqContext(_ctx, getState());
enterRule(_localctx, 134, RULE_declspecifierseq);
try {
setState(1252);
switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1245);
declspecifier();
setState(1247);
switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) {
case 1:
{
setState(1246);
attributespecifierseq(0);
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1249);
declspecifier();
setState(1250);
declspecifierseq();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StorageclassspecifierContext extends ParserRuleContext {
public TerminalNode Register() { return getToken(CPP14Parser.Register, 0); }
public TerminalNode Static() { return getToken(CPP14Parser.Static, 0); }
public TerminalNode Thread_local() { return getToken(CPP14Parser.Thread_local, 0); }
public TerminalNode Extern() { return getToken(CPP14Parser.Extern, 0); }
public TerminalNode Mutable() { return getToken(CPP14Parser.Mutable, 0); }
public StorageclassspecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_storageclassspecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterStorageclassspecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitStorageclassspecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitStorageclassspecifier(this);
else return visitor.visitChildren(this);
}
}
public final StorageclassspecifierContext storageclassspecifier() throws RecognitionException {
StorageclassspecifierContext _localctx = new StorageclassspecifierContext(_ctx, getState());
enterRule(_localctx, 136, RULE_storageclassspecifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1254);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Extern) | (1L << Mutable) | (1L << Register) | (1L << Static) | (1L << Thread_local))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctionspecifierContext extends ParserRuleContext {
public TerminalNode Inline() { return getToken(CPP14Parser.Inline, 0); }
public TerminalNode Virtual() { return getToken(CPP14Parser.Virtual, 0); }
public TerminalNode Explicit() { return getToken(CPP14Parser.Explicit, 0); }
public FunctionspecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionspecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterFunctionspecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitFunctionspecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitFunctionspecifier(this);
else return visitor.visitChildren(this);
}
}
public final FunctionspecifierContext functionspecifier() throws RecognitionException {
FunctionspecifierContext _localctx = new FunctionspecifierContext(_ctx, getState());
enterRule(_localctx, 138, RULE_functionspecifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1256);
_la = _input.LA(1);
if ( !(((((_la - 27)) & ~0x3f) == 0 && ((1L << (_la - 27)) & ((1L << (Explicit - 27)) | (1L << (Inline - 27)) | (1L << (Virtual - 27)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypedefnameContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public TypedefnameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typedefname; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypedefname(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypedefname(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTypedefname(this);
else return visitor.visitChildren(this);
}
}
public final TypedefnameContext typedefname() throws RecognitionException {
TypedefnameContext _localctx = new TypedefnameContext(_ctx, getState());
enterRule(_localctx, 140, RULE_typedefname);
try {
enterOuterAlt(_localctx, 1);
{
setState(1258);
match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypespecifierContext extends ParserRuleContext {
public TrailingtypespecifierContext trailingtypespecifier() {
return getRuleContext(TrailingtypespecifierContext.class,0);
}
public ClassspecifierContext classspecifier() {
return getRuleContext(ClassspecifierContext.class,0);
}
public EnumspecifierContext enumspecifier() {
return getRuleContext(EnumspecifierContext.class,0);
}
public TypespecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typespecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypespecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypespecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTypespecifier(this);
else return visitor.visitChildren(this);
}
}
public final TypespecifierContext typespecifier() throws RecognitionException {
TypespecifierContext _localctx = new TypespecifierContext(_ctx, getState());
enterRule(_localctx, 142, RULE_typespecifier);
try {
setState(1263);
switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1260);
trailingtypespecifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1261);
classspecifier();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1262);
enumspecifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TrailingtypespecifierContext extends ParserRuleContext {
public SimpletypespecifierContext simpletypespecifier() {
return getRuleContext(SimpletypespecifierContext.class,0);
}
public ElaboratedtypespecifierContext elaboratedtypespecifier() {
return getRuleContext(ElaboratedtypespecifierContext.class,0);
}
public TypenamespecifierContext typenamespecifier() {
return getRuleContext(TypenamespecifierContext.class,0);
}
public CvqualifierContext cvqualifier() {
return getRuleContext(CvqualifierContext.class,0);
}
public TrailingtypespecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trailingtypespecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTrailingtypespecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTrailingtypespecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTrailingtypespecifier(this);
else return visitor.visitChildren(this);
}
}
public final TrailingtypespecifierContext trailingtypespecifier() throws RecognitionException {
TrailingtypespecifierContext _localctx = new TrailingtypespecifierContext(_ctx, getState());
enterRule(_localctx, 144, RULE_trailingtypespecifier);
try {
setState(1269);
switch (_input.LA(1)) {
case Auto:
case Bool:
case Char:
case Char16:
case Char32:
case Decltype:
case Double:
case Float:
case Int:
case Long:
case Short:
case Signed:
case Unsigned:
case Void:
case Wchar:
case Doublecolon:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(1265);
simpletypespecifier();
}
break;
case Class:
case Enum:
case Struct:
case Union:
enterOuterAlt(_localctx, 2);
{
setState(1266);
elaboratedtypespecifier();
}
break;
case Typename:
enterOuterAlt(_localctx, 3);
{
setState(1267);
typenamespecifier();
}
break;
case Const:
case Volatile:
enterOuterAlt(_localctx, 4);
{
setState(1268);
cvqualifier();
}
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 TypespecifierseqContext extends ParserRuleContext {
public TypespecifierContext typespecifier() {
return getRuleContext(TypespecifierContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public TypespecifierseqContext typespecifierseq() {
return getRuleContext(TypespecifierseqContext.class,0);
}
public TypespecifierseqContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typespecifierseq; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypespecifierseq(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypespecifierseq(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTypespecifierseq(this);
else return visitor.visitChildren(this);
}
}
public final TypespecifierseqContext typespecifierseq() throws RecognitionException {
TypespecifierseqContext _localctx = new TypespecifierseqContext(_ctx, getState());
enterRule(_localctx, 146, RULE_typespecifierseq);
try {
setState(1278);
switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1271);
typespecifier();
setState(1273);
switch ( getInterpreter().adaptivePredict(_input,113,_ctx) ) {
case 1:
{
setState(1272);
attributespecifierseq(0);
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1275);
typespecifier();
setState(1276);
typespecifierseq();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TrailingtypespecifierseqContext extends ParserRuleContext {
public TrailingtypespecifierContext trailingtypespecifier() {
return getRuleContext(TrailingtypespecifierContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public TrailingtypespecifierseqContext trailingtypespecifierseq() {
return getRuleContext(TrailingtypespecifierseqContext.class,0);
}
public TrailingtypespecifierseqContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trailingtypespecifierseq; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTrailingtypespecifierseq(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTrailingtypespecifierseq(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTrailingtypespecifierseq(this);
else return visitor.visitChildren(this);
}
}
public final TrailingtypespecifierseqContext trailingtypespecifierseq() throws RecognitionException {
TrailingtypespecifierseqContext _localctx = new TrailingtypespecifierseqContext(_ctx, getState());
enterRule(_localctx, 148, RULE_trailingtypespecifierseq);
try {
setState(1287);
switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1280);
trailingtypespecifier();
setState(1282);
switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) {
case 1:
{
setState(1281);
attributespecifierseq(0);
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1284);
trailingtypespecifier();
setState(1285);
trailingtypespecifierseq();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpletypespecifierContext extends ParserRuleContext {
public TypenameContext typename() {
return getRuleContext(TypenameContext.class,0);
}
public NestednamespecifierContext nestednamespecifier() {
return getRuleContext(NestednamespecifierContext.class,0);
}
public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
public SimpletemplateidContext simpletemplateid() {
return getRuleContext(SimpletemplateidContext.class,0);
}
public TerminalNode Char() { return getToken(CPP14Parser.Char, 0); }
public TerminalNode Char16() { return getToken(CPP14Parser.Char16, 0); }
public TerminalNode Char32() { return getToken(CPP14Parser.Char32, 0); }
public TerminalNode Wchar() { return getToken(CPP14Parser.Wchar, 0); }
public TerminalNode Bool() { return getToken(CPP14Parser.Bool, 0); }
public TerminalNode Short() { return getToken(CPP14Parser.Short, 0); }
public TerminalNode Int() { return getToken(CPP14Parser.Int, 0); }
public TerminalNode Long() { return getToken(CPP14Parser.Long, 0); }
public TerminalNode Signed() { return getToken(CPP14Parser.Signed, 0); }
public TerminalNode Unsigned() { return getToken(CPP14Parser.Unsigned, 0); }
public TerminalNode Float() { return getToken(CPP14Parser.Float, 0); }
public TerminalNode Double() { return getToken(CPP14Parser.Double, 0); }
public TerminalNode Void() { return getToken(CPP14Parser.Void, 0); }
public TerminalNode Auto() { return getToken(CPP14Parser.Auto, 0); }
public DecltypespecifierContext decltypespecifier() {
return getRuleContext(DecltypespecifierContext.class,0);
}
public SimpletypespecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpletypespecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterSimpletypespecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitSimpletypespecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitSimpletypespecifier(this);
else return visitor.visitChildren(this);
}
}
public final SimpletypespecifierContext simpletypespecifier() throws RecognitionException {
SimpletypespecifierContext _localctx = new SimpletypespecifierContext(_ctx, getState());
enterRule(_localctx, 150, RULE_simpletypespecifier);
try {
setState(1312);
switch ( getInterpreter().adaptivePredict(_input,118,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1290);
switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) {
case 1:
{
setState(1289);
nestednamespecifier(0);
}
break;
}
setState(1292);
typename();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1293);
nestednamespecifier(0);
setState(1294);
match(Template);
setState(1295);
simpletemplateid();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1297);
match(Char);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1298);
match(Char16);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(1299);
match(Char32);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(1300);
match(Wchar);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(1301);
match(Bool);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(1302);
match(Short);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(1303);
match(Int);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(1304);
match(Long);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(1305);
match(Signed);
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(1306);
match(Unsigned);
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(1307);
match(Float);
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(1308);
match(Double);
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(1309);
match(Void);
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(1310);
match(Auto);
}
break;
case 17:
enterOuterAlt(_localctx, 17);
{
setState(1311);
decltypespecifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypenameContext extends ParserRuleContext {
public ClassnameContext classname() {
return getRuleContext(ClassnameContext.class,0);
}
public EnumnameContext enumname() {
return getRuleContext(EnumnameContext.class,0);
}
public TypedefnameContext typedefname() {
return getRuleContext(TypedefnameContext.class,0);
}
public SimpletemplateidContext simpletemplateid() {
return getRuleContext(SimpletemplateidContext.class,0);
}
public TypenameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typename; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypename(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypename(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTypename(this);
else return visitor.visitChildren(this);
}
}
public final TypenameContext typename() throws RecognitionException {
TypenameContext _localctx = new TypenameContext(_ctx, getState());
enterRule(_localctx, 152, RULE_typename);
try {
setState(1318);
switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1314);
classname();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1315);
enumname();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1316);
typedefname();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1317);
simpletemplateid();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DecltypespecifierContext extends ParserRuleContext {
public TerminalNode Decltype() { return getToken(CPP14Parser.Decltype, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode Auto() { return getToken(CPP14Parser.Auto, 0); }
public DecltypespecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_decltypespecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDecltypespecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDecltypespecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitDecltypespecifier(this);
else return visitor.visitChildren(this);
}
}
public final DecltypespecifierContext decltypespecifier() throws RecognitionException {
DecltypespecifierContext _localctx = new DecltypespecifierContext(_ctx, getState());
enterRule(_localctx, 154, RULE_decltypespecifier);
try {
setState(1329);
switch ( getInterpreter().adaptivePredict(_input,120,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1320);
match(Decltype);
setState(1321);
match(LeftParen);
setState(1322);
expression(0);
setState(1323);
match(RightParen);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1325);
match(Decltype);
setState(1326);
match(LeftParen);
setState(1327);
match(Auto);
setState(1328);
match(RightParen);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ElaboratedtypespecifierContext extends ParserRuleContext {
public ClasskeyContext classkey() {
return getRuleContext(ClasskeyContext.class,0);
}
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public NestednamespecifierContext nestednamespecifier() {
return getRuleContext(NestednamespecifierContext.class,0);
}
public SimpletemplateidContext simpletemplateid() {
return getRuleContext(SimpletemplateidContext.class,0);
}
public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
public TerminalNode Enum() { return getToken(CPP14Parser.Enum, 0); }
public ElaboratedtypespecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_elaboratedtypespecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterElaboratedtypespecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitElaboratedtypespecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitElaboratedtypespecifier(this);
else return visitor.visitChildren(this);
}
}
public final ElaboratedtypespecifierContext elaboratedtypespecifier() throws RecognitionException {
ElaboratedtypespecifierContext _localctx = new ElaboratedtypespecifierContext(_ctx, getState());
enterRule(_localctx, 156, RULE_elaboratedtypespecifier);
int _la;
try {
setState(1355);
switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1331);
classkey();
setState(1333);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1332);
attributespecifierseq(0);
}
}
setState(1336);
switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) {
case 1:
{
setState(1335);
nestednamespecifier(0);
}
break;
}
setState(1338);
match(Identifier);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1340);
classkey();
setState(1341);
simpletemplateid();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1343);
classkey();
setState(1344);
nestednamespecifier(0);
setState(1346);
_la = _input.LA(1);
if (_la==Template) {
{
setState(1345);
match(Template);
}
}
setState(1348);
simpletemplateid();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1350);
match(Enum);
setState(1352);
switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
case 1:
{
setState(1351);
nestednamespecifier(0);
}
break;
}
setState(1354);
match(Identifier);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumnameContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public EnumnameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumname; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEnumname(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEnumname(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitEnumname(this);
else return visitor.visitChildren(this);
}
}
public final EnumnameContext enumname() throws RecognitionException {
EnumnameContext _localctx = new EnumnameContext(_ctx, getState());
enterRule(_localctx, 158, RULE_enumname);
try {
enterOuterAlt(_localctx, 1);
{
setState(1357);
match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumspecifierContext extends ParserRuleContext {
public EnumheadContext enumhead() {
return getRuleContext(EnumheadContext.class,0);
}
public EnumeratorlistContext enumeratorlist() {
return getRuleContext(EnumeratorlistContext.class,0);
}
public EnumspecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumspecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEnumspecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEnumspecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitEnumspecifier(this);
else return visitor.visitChildren(this);
}
}
public final EnumspecifierContext enumspecifier() throws RecognitionException {
EnumspecifierContext _localctx = new EnumspecifierContext(_ctx, getState());
enterRule(_localctx, 160, RULE_enumspecifier);
int _la;
try {
setState(1372);
switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1359);
enumhead();
setState(1360);
match(LeftBrace);
setState(1362);
_la = _input.LA(1);
if (_la==Identifier) {
{
setState(1361);
enumeratorlist(0);
}
}
setState(1364);
match(RightBrace);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1366);
enumhead();
setState(1367);
match(LeftBrace);
setState(1368);
enumeratorlist(0);
setState(1369);
match(Comma);
setState(1370);
match(RightBrace);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumheadContext extends ParserRuleContext {
public EnumkeyContext enumkey() {
return getRuleContext(EnumkeyContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public EnumbaseContext enumbase() {
return getRuleContext(EnumbaseContext.class,0);
}
public NestednamespecifierContext nestednamespecifier() {
return getRuleContext(NestednamespecifierContext.class,0);
}
public EnumheadContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumhead; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEnumhead(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEnumhead(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitEnumhead(this);
else return visitor.visitChildren(this);
}
}
public final EnumheadContext enumhead() throws RecognitionException {
EnumheadContext _localctx = new EnumheadContext(_ctx, getState());
enterRule(_localctx, 162, RULE_enumhead);
int _la;
try {
setState(1393);
switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1374);
enumkey();
setState(1376);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1375);
attributespecifierseq(0);
}
}
setState(1379);
_la = _input.LA(1);
if (_la==Identifier) {
{
setState(1378);
match(Identifier);
}
}
setState(1382);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(1381);
enumbase();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1384);
enumkey();
setState(1386);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1385);
attributespecifierseq(0);
}
}
setState(1388);
nestednamespecifier(0);
setState(1389);
match(Identifier);
setState(1391);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(1390);
enumbase();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OpaqueenumdeclarationContext extends ParserRuleContext {
public EnumkeyContext enumkey() {
return getRuleContext(EnumkeyContext.class,0);
}
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public EnumbaseContext enumbase() {
return getRuleContext(EnumbaseContext.class,0);
}
public OpaqueenumdeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_opaqueenumdeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterOpaqueenumdeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitOpaqueenumdeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitOpaqueenumdeclaration(this);
else return visitor.visitChildren(this);
}
}
public final OpaqueenumdeclarationContext opaqueenumdeclaration() throws RecognitionException {
OpaqueenumdeclarationContext _localctx = new OpaqueenumdeclarationContext(_ctx, getState());
enterRule(_localctx, 164, RULE_opaqueenumdeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1395);
enumkey();
setState(1397);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1396);
attributespecifierseq(0);
}
}
setState(1399);
match(Identifier);
setState(1401);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(1400);
enumbase();
}
}
setState(1403);
match(Semi);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumkeyContext extends ParserRuleContext {
public TerminalNode Enum() { return getToken(CPP14Parser.Enum, 0); }
public TerminalNode Class() { return getToken(CPP14Parser.Class, 0); }
public TerminalNode Struct() { return getToken(CPP14Parser.Struct, 0); }
public EnumkeyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumkey; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEnumkey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEnumkey(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitEnumkey(this);
else return visitor.visitChildren(this);
}
}
public final EnumkeyContext enumkey() throws RecognitionException {
EnumkeyContext _localctx = new EnumkeyContext(_ctx, getState());
enterRule(_localctx, 166, RULE_enumkey);
try {
setState(1410);
switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1405);
match(Enum);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1406);
match(Enum);
setState(1407);
match(Class);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1408);
match(Enum);
setState(1409);
match(Struct);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumbaseContext extends ParserRuleContext {
public TypespecifierseqContext typespecifierseq() {
return getRuleContext(TypespecifierseqContext.class,0);
}
public EnumbaseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumbase; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEnumbase(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEnumbase(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitEnumbase(this);
else return visitor.visitChildren(this);
}
}
public final EnumbaseContext enumbase() throws RecognitionException {
EnumbaseContext _localctx = new EnumbaseContext(_ctx, getState());
enterRule(_localctx, 168, RULE_enumbase);
try {
enterOuterAlt(_localctx, 1);
{
setState(1412);
match(Colon);
setState(1413);
typespecifierseq();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumeratorlistContext extends ParserRuleContext {
public EnumeratordefinitionContext enumeratordefinition() {
return getRuleContext(EnumeratordefinitionContext.class,0);
}
public EnumeratorlistContext enumeratorlist() {
return getRuleContext(EnumeratorlistContext.class,0);
}
public EnumeratorlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumeratorlist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEnumeratorlist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEnumeratorlist(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitEnumeratorlist(this);
else return visitor.visitChildren(this);
}
}
public final EnumeratorlistContext enumeratorlist() throws RecognitionException {
return enumeratorlist(0);
}
private EnumeratorlistContext enumeratorlist(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
EnumeratorlistContext _localctx = new EnumeratorlistContext(_ctx, _parentState);
EnumeratorlistContext _prevctx = _localctx;
int _startState = 170;
enterRecursionRule(_localctx, 170, RULE_enumeratorlist, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1416);
enumeratordefinition();
}
_ctx.stop = _input.LT(-1);
setState(1423);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,137,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new EnumeratorlistContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_enumeratorlist);
setState(1418);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1419);
match(Comma);
setState(1420);
enumeratordefinition();
}
}
}
setState(1425);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,137,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class EnumeratordefinitionContext extends ParserRuleContext {
public EnumeratorContext enumerator() {
return getRuleContext(EnumeratorContext.class,0);
}
public ConstantexpressionContext constantexpression() {
return getRuleContext(ConstantexpressionContext.class,0);
}
public EnumeratordefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumeratordefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEnumeratordefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEnumeratordefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitEnumeratordefinition(this);
else return visitor.visitChildren(this);
}
}
public final EnumeratordefinitionContext enumeratordefinition() throws RecognitionException {
EnumeratordefinitionContext _localctx = new EnumeratordefinitionContext(_ctx, getState());
enterRule(_localctx, 172, RULE_enumeratordefinition);
try {
setState(1431);
switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1426);
enumerator();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1427);
enumerator();
setState(1428);
match(Assign);
setState(1429);
constantexpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumeratorContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public EnumeratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumerator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterEnumerator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitEnumerator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitEnumerator(this);
else return visitor.visitChildren(this);
}
}
public final EnumeratorContext enumerator() throws RecognitionException {
EnumeratorContext _localctx = new EnumeratorContext(_ctx, getState());
enterRule(_localctx, 174, RULE_enumerator);
try {
enterOuterAlt(_localctx, 1);
{
setState(1433);
match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NamespacenameContext extends ParserRuleContext {
public OriginalnamespacenameContext originalnamespacename() {
return getRuleContext(OriginalnamespacenameContext.class,0);
}
public NamespacealiasContext namespacealias() {
return getRuleContext(NamespacealiasContext.class,0);
}
public NamespacenameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namespacename; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNamespacename(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNamespacename(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNamespacename(this);
else return visitor.visitChildren(this);
}
}
public final NamespacenameContext namespacename() throws RecognitionException {
NamespacenameContext _localctx = new NamespacenameContext(_ctx, getState());
enterRule(_localctx, 176, RULE_namespacename);
try {
setState(1437);
switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1435);
originalnamespacename();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1436);
namespacealias();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OriginalnamespacenameContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public OriginalnamespacenameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_originalnamespacename; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterOriginalnamespacename(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitOriginalnamespacename(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitOriginalnamespacename(this);
else return visitor.visitChildren(this);
}
}
public final OriginalnamespacenameContext originalnamespacename() throws RecognitionException {
OriginalnamespacenameContext _localctx = new OriginalnamespacenameContext(_ctx, getState());
enterRule(_localctx, 178, RULE_originalnamespacename);
try {
enterOuterAlt(_localctx, 1);
{
setState(1439);
match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NamespacedefinitionContext extends ParserRuleContext {
public NamednamespacedefinitionContext namednamespacedefinition() {
return getRuleContext(NamednamespacedefinitionContext.class,0);
}
public UnnamednamespacedefinitionContext unnamednamespacedefinition() {
return getRuleContext(UnnamednamespacedefinitionContext.class,0);
}
public NamespacedefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namespacedefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNamespacedefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNamespacedefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNamespacedefinition(this);
else return visitor.visitChildren(this);
}
}
public final NamespacedefinitionContext namespacedefinition() throws RecognitionException {
NamespacedefinitionContext _localctx = new NamespacedefinitionContext(_ctx, getState());
enterRule(_localctx, 180, RULE_namespacedefinition);
try {
setState(1443);
switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1441);
namednamespacedefinition();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1442);
unnamednamespacedefinition();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NamednamespacedefinitionContext extends ParserRuleContext {
public OriginalnamespacedefinitionContext originalnamespacedefinition() {
return getRuleContext(OriginalnamespacedefinitionContext.class,0);
}
public ExtensionnamespacedefinitionContext extensionnamespacedefinition() {
return getRuleContext(ExtensionnamespacedefinitionContext.class,0);
}
public NamednamespacedefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namednamespacedefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNamednamespacedefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNamednamespacedefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNamednamespacedefinition(this);
else return visitor.visitChildren(this);
}
}
public final NamednamespacedefinitionContext namednamespacedefinition() throws RecognitionException {
NamednamespacedefinitionContext _localctx = new NamednamespacedefinitionContext(_ctx, getState());
enterRule(_localctx, 182, RULE_namednamespacedefinition);
try {
setState(1447);
switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1445);
originalnamespacedefinition();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1446);
extensionnamespacedefinition();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OriginalnamespacedefinitionContext extends ParserRuleContext {
public TerminalNode Namespace() { return getToken(CPP14Parser.Namespace, 0); }
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public NamespacebodyContext namespacebody() {
return getRuleContext(NamespacebodyContext.class,0);
}
public TerminalNode Inline() { return getToken(CPP14Parser.Inline, 0); }
public OriginalnamespacedefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_originalnamespacedefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterOriginalnamespacedefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitOriginalnamespacedefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitOriginalnamespacedefinition(this);
else return visitor.visitChildren(this);
}
}
public final OriginalnamespacedefinitionContext originalnamespacedefinition() throws RecognitionException {
OriginalnamespacedefinitionContext _localctx = new OriginalnamespacedefinitionContext(_ctx, getState());
enterRule(_localctx, 184, RULE_originalnamespacedefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1450);
_la = _input.LA(1);
if (_la==Inline) {
{
setState(1449);
match(Inline);
}
}
setState(1452);
match(Namespace);
setState(1453);
match(Identifier);
setState(1454);
match(LeftBrace);
setState(1455);
namespacebody();
setState(1456);
match(RightBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExtensionnamespacedefinitionContext extends ParserRuleContext {
public TerminalNode Namespace() { return getToken(CPP14Parser.Namespace, 0); }
public OriginalnamespacenameContext originalnamespacename() {
return getRuleContext(OriginalnamespacenameContext.class,0);
}
public NamespacebodyContext namespacebody() {
return getRuleContext(NamespacebodyContext.class,0);
}
public TerminalNode Inline() { return getToken(CPP14Parser.Inline, 0); }
public ExtensionnamespacedefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_extensionnamespacedefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExtensionnamespacedefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExtensionnamespacedefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitExtensionnamespacedefinition(this);
else return visitor.visitChildren(this);
}
}
public final ExtensionnamespacedefinitionContext extensionnamespacedefinition() throws RecognitionException {
ExtensionnamespacedefinitionContext _localctx = new ExtensionnamespacedefinitionContext(_ctx, getState());
enterRule(_localctx, 186, RULE_extensionnamespacedefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1459);
_la = _input.LA(1);
if (_la==Inline) {
{
setState(1458);
match(Inline);
}
}
setState(1461);
match(Namespace);
setState(1462);
originalnamespacename();
setState(1463);
match(LeftBrace);
setState(1464);
namespacebody();
setState(1465);
match(RightBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnnamednamespacedefinitionContext extends ParserRuleContext {
public TerminalNode Namespace() { return getToken(CPP14Parser.Namespace, 0); }
public NamespacebodyContext namespacebody() {
return getRuleContext(NamespacebodyContext.class,0);
}
public TerminalNode Inline() { return getToken(CPP14Parser.Inline, 0); }
public UnnamednamespacedefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unnamednamespacedefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterUnnamednamespacedefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitUnnamednamespacedefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitUnnamednamespacedefinition(this);
else return visitor.visitChildren(this);
}
}
public final UnnamednamespacedefinitionContext unnamednamespacedefinition() throws RecognitionException {
UnnamednamespacedefinitionContext _localctx = new UnnamednamespacedefinitionContext(_ctx, getState());
enterRule(_localctx, 188, RULE_unnamednamespacedefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1468);
_la = _input.LA(1);
if (_la==Inline) {
{
setState(1467);
match(Inline);
}
}
setState(1470);
match(Namespace);
setState(1471);
match(LeftBrace);
setState(1472);
namespacebody();
setState(1473);
match(RightBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NamespacebodyContext extends ParserRuleContext {
public DeclarationseqContext declarationseq() {
return getRuleContext(DeclarationseqContext.class,0);
}
public NamespacebodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namespacebody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNamespacebody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNamespacebody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNamespacebody(this);
else return visitor.visitChildren(this);
}
}
public final NamespacebodyContext namespacebody() throws RecognitionException {
NamespacebodyContext _localctx = new NamespacebodyContext(_ctx, getState());
enterRule(_localctx, 190, RULE_namespacebody);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1476);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignas) | (1L << Asm) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Decltype) | (1L << Double) | (1L << Enum) | (1L << Explicit) | (1L << Extern) | (1L << Float) | (1L << Friend) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << Namespace) | (1L << Operator) | (1L << Register) | (1L << Short) | (1L << Signed) | (1L << Static) | (1L << Static_assert) | (1L << Struct) | (1L << Template) | (1L << Thread_local))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (Typedef - 67)) | (1L << (Typename - 67)) | (1L << (Union - 67)) | (1L << (Unsigned - 67)) | (1L << (Using - 67)) | (1L << (Virtual - 67)) | (1L << (Void - 67)) | (1L << (Volatile - 67)) | (1L << (Wchar - 67)) | (1L << (LeftParen - 67)) | (1L << (LeftBracket - 67)) | (1L << (Star - 67)) | (1L << (And - 67)) | (1L << (Tilde - 67)) | (1L << (AndAnd - 67)) | (1L << (Doublecolon - 67)) | (1L << (Semi - 67)) | (1L << (Ellipsis - 67)) | (1L << (Identifier - 67)))) != 0)) {
{
setState(1475);
declarationseq(0);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NamespacealiasContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public NamespacealiasContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namespacealias; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNamespacealias(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNamespacealias(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNamespacealias(this);
else return visitor.visitChildren(this);
}
}
public final NamespacealiasContext namespacealias() throws RecognitionException {
NamespacealiasContext _localctx = new NamespacealiasContext(_ctx, getState());
enterRule(_localctx, 192, RULE_namespacealias);
try {
enterOuterAlt(_localctx, 1);
{
setState(1478);
match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NamespacealiasdefinitionContext extends ParserRuleContext {
public TerminalNode Namespace() { return getToken(CPP14Parser.Namespace, 0); }
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public QualifiednamespacespecifierContext qualifiednamespacespecifier() {
return getRuleContext(QualifiednamespacespecifierContext.class,0);
}
public NamespacealiasdefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_namespacealiasdefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNamespacealiasdefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNamespacealiasdefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNamespacealiasdefinition(this);
else return visitor.visitChildren(this);
}
}
public final NamespacealiasdefinitionContext namespacealiasdefinition() throws RecognitionException {
NamespacealiasdefinitionContext _localctx = new NamespacealiasdefinitionContext(_ctx, getState());
enterRule(_localctx, 194, RULE_namespacealiasdefinition);
try {
enterOuterAlt(_localctx, 1);
{
setState(1480);
match(Namespace);
setState(1481);
match(Identifier);
setState(1482);
match(Assign);
setState(1483);
qualifiednamespacespecifier();
setState(1484);
match(Semi);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class QualifiednamespacespecifierContext extends ParserRuleContext {
public NamespacenameContext namespacename() {
return getRuleContext(NamespacenameContext.class,0);
}
public NestednamespecifierContext nestednamespecifier() {
return getRuleContext(NestednamespecifierContext.class,0);
}
public QualifiednamespacespecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_qualifiednamespacespecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterQualifiednamespacespecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitQualifiednamespacespecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitQualifiednamespacespecifier(this);
else return visitor.visitChildren(this);
}
}
public final QualifiednamespacespecifierContext qualifiednamespacespecifier() throws RecognitionException {
QualifiednamespacespecifierContext _localctx = new QualifiednamespacespecifierContext(_ctx, getState());
enterRule(_localctx, 196, RULE_qualifiednamespacespecifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(1487);
switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
case 1:
{
setState(1486);
nestednamespecifier(0);
}
break;
}
setState(1489);
namespacename();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UsingdeclarationContext extends ParserRuleContext {
public TerminalNode Using() { return getToken(CPP14Parser.Using, 0); }
public NestednamespecifierContext nestednamespecifier() {
return getRuleContext(NestednamespecifierContext.class,0);
}
public UnqualifiedidContext unqualifiedid() {
return getRuleContext(UnqualifiedidContext.class,0);
}
public TerminalNode Typename() { return getToken(CPP14Parser.Typename, 0); }
public UsingdeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_usingdeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterUsingdeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitUsingdeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitUsingdeclaration(this);
else return visitor.visitChildren(this);
}
}
public final UsingdeclarationContext usingdeclaration() throws RecognitionException {
UsingdeclarationContext _localctx = new UsingdeclarationContext(_ctx, getState());
enterRule(_localctx, 198, RULE_usingdeclaration);
int _la;
try {
setState(1504);
switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1491);
match(Using);
setState(1493);
_la = _input.LA(1);
if (_la==Typename) {
{
setState(1492);
match(Typename);
}
}
setState(1495);
nestednamespecifier(0);
setState(1496);
unqualifiedid();
setState(1497);
match(Semi);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1499);
match(Using);
setState(1500);
match(Doublecolon);
setState(1501);
unqualifiedid();
setState(1502);
match(Semi);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UsingdirectiveContext extends ParserRuleContext {
public TerminalNode Using() { return getToken(CPP14Parser.Using, 0); }
public TerminalNode Namespace() { return getToken(CPP14Parser.Namespace, 0); }
public NamespacenameContext namespacename() {
return getRuleContext(NamespacenameContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public NestednamespecifierContext nestednamespecifier() {
return getRuleContext(NestednamespecifierContext.class,0);
}
public UsingdirectiveContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_usingdirective; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterUsingdirective(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitUsingdirective(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitUsingdirective(this);
else return visitor.visitChildren(this);
}
}
public final UsingdirectiveContext usingdirective() throws RecognitionException {
UsingdirectiveContext _localctx = new UsingdirectiveContext(_ctx, getState());
enterRule(_localctx, 200, RULE_usingdirective);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1507);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1506);
attributespecifierseq(0);
}
}
setState(1509);
match(Using);
setState(1510);
match(Namespace);
setState(1512);
switch ( getInterpreter().adaptivePredict(_input,150,_ctx) ) {
case 1:
{
setState(1511);
nestednamespecifier(0);
}
break;
}
setState(1514);
namespacename();
setState(1515);
match(Semi);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AsmdefinitionContext extends ParserRuleContext {
public TerminalNode Asm() { return getToken(CPP14Parser.Asm, 0); }
public TerminalNode Stringliteral() { return getToken(CPP14Parser.Stringliteral, 0); }
public AsmdefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_asmdefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAsmdefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAsmdefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAsmdefinition(this);
else return visitor.visitChildren(this);
}
}
public final AsmdefinitionContext asmdefinition() throws RecognitionException {
AsmdefinitionContext _localctx = new AsmdefinitionContext(_ctx, getState());
enterRule(_localctx, 202, RULE_asmdefinition);
try {
enterOuterAlt(_localctx, 1);
{
setState(1517);
match(Asm);
setState(1518);
match(LeftParen);
setState(1519);
match(Stringliteral);
setState(1520);
match(RightParen);
setState(1521);
match(Semi);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LinkagespecificationContext extends ParserRuleContext {
public TerminalNode Extern() { return getToken(CPP14Parser.Extern, 0); }
public TerminalNode Stringliteral() { return getToken(CPP14Parser.Stringliteral, 0); }
public DeclarationseqContext declarationseq() {
return getRuleContext(DeclarationseqContext.class,0);
}
public DeclarationContext declaration() {
return getRuleContext(DeclarationContext.class,0);
}
public LinkagespecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_linkagespecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLinkagespecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLinkagespecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitLinkagespecification(this);
else return visitor.visitChildren(this);
}
}
public final LinkagespecificationContext linkagespecification() throws RecognitionException {
LinkagespecificationContext _localctx = new LinkagespecificationContext(_ctx, getState());
enterRule(_localctx, 204, RULE_linkagespecification);
int _la;
try {
setState(1533);
switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1523);
match(Extern);
setState(1524);
match(Stringliteral);
setState(1525);
match(LeftBrace);
setState(1527);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignas) | (1L << Asm) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Decltype) | (1L << Double) | (1L << Enum) | (1L << Explicit) | (1L << Extern) | (1L << Float) | (1L << Friend) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << Namespace) | (1L << Operator) | (1L << Register) | (1L << Short) | (1L << Signed) | (1L << Static) | (1L << Static_assert) | (1L << Struct) | (1L << Template) | (1L << Thread_local))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (Typedef - 67)) | (1L << (Typename - 67)) | (1L << (Union - 67)) | (1L << (Unsigned - 67)) | (1L << (Using - 67)) | (1L << (Virtual - 67)) | (1L << (Void - 67)) | (1L << (Volatile - 67)) | (1L << (Wchar - 67)) | (1L << (LeftParen - 67)) | (1L << (LeftBracket - 67)) | (1L << (Star - 67)) | (1L << (And - 67)) | (1L << (Tilde - 67)) | (1L << (AndAnd - 67)) | (1L << (Doublecolon - 67)) | (1L << (Semi - 67)) | (1L << (Ellipsis - 67)) | (1L << (Identifier - 67)))) != 0)) {
{
setState(1526);
declarationseq(0);
}
}
setState(1529);
match(RightBrace);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1530);
match(Extern);
setState(1531);
match(Stringliteral);
setState(1532);
declaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributespecifierseqContext extends ParserRuleContext {
public AttributespecifierContext attributespecifier() {
return getRuleContext(AttributespecifierContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public AttributespecifierseqContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributespecifierseq; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttributespecifierseq(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttributespecifierseq(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAttributespecifierseq(this);
else return visitor.visitChildren(this);
}
}
public final AttributespecifierseqContext attributespecifierseq() throws RecognitionException {
return attributespecifierseq(0);
}
private AttributespecifierseqContext attributespecifierseq(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
AttributespecifierseqContext _localctx = new AttributespecifierseqContext(_ctx, _parentState);
AttributespecifierseqContext _prevctx = _localctx;
int _startState = 206;
enterRecursionRule(_localctx, 206, RULE_attributespecifierseq, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1536);
attributespecifier();
}
_ctx.stop = _input.LT(-1);
setState(1542);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,153,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new AttributespecifierseqContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_attributespecifierseq);
setState(1538);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1539);
attributespecifier();
}
}
}
setState(1544);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,153,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class AttributespecifierContext extends ParserRuleContext {
public AttributelistContext attributelist() {
return getRuleContext(AttributelistContext.class,0);
}
public AlignmentspecifierContext alignmentspecifier() {
return getRuleContext(AlignmentspecifierContext.class,0);
}
public AttributespecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributespecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttributespecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttributespecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAttributespecifier(this);
else return visitor.visitChildren(this);
}
}
public final AttributespecifierContext attributespecifier() throws RecognitionException {
AttributespecifierContext _localctx = new AttributespecifierContext(_ctx, getState());
enterRule(_localctx, 208, RULE_attributespecifier);
try {
setState(1552);
switch (_input.LA(1)) {
case LeftBracket:
enterOuterAlt(_localctx, 1);
{
setState(1545);
match(LeftBracket);
setState(1546);
match(LeftBracket);
setState(1547);
attributelist(0);
setState(1548);
match(RightBracket);
setState(1549);
match(RightBracket);
}
break;
case Alignas:
enterOuterAlt(_localctx, 2);
{
setState(1551);
alignmentspecifier();
}
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 AlignmentspecifierContext extends ParserRuleContext {
public TerminalNode Alignas() { return getToken(CPP14Parser.Alignas, 0); }
public TypeidContext typeid() {
return getRuleContext(TypeidContext.class,0);
}
public ConstantexpressionContext constantexpression() {
return getRuleContext(ConstantexpressionContext.class,0);
}
public AlignmentspecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_alignmentspecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAlignmentspecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAlignmentspecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAlignmentspecifier(this);
else return visitor.visitChildren(this);
}
}
public final AlignmentspecifierContext alignmentspecifier() throws RecognitionException {
AlignmentspecifierContext _localctx = new AlignmentspecifierContext(_ctx, getState());
enterRule(_localctx, 210, RULE_alignmentspecifier);
int _la;
try {
setState(1570);
switch ( getInterpreter().adaptivePredict(_input,157,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1554);
match(Alignas);
setState(1555);
match(LeftParen);
setState(1556);
typeid();
setState(1558);
_la = _input.LA(1);
if (_la==Ellipsis) {
{
setState(1557);
match(Ellipsis);
}
}
setState(1560);
match(RightParen);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1562);
match(Alignas);
setState(1563);
match(LeftParen);
setState(1564);
constantexpression();
setState(1566);
_la = _input.LA(1);
if (_la==Ellipsis) {
{
setState(1565);
match(Ellipsis);
}
}
setState(1568);
match(RightParen);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributelistContext extends ParserRuleContext {
public AttributeContext attribute() {
return getRuleContext(AttributeContext.class,0);
}
public AttributelistContext attributelist() {
return getRuleContext(AttributelistContext.class,0);
}
public AttributelistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributelist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttributelist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttributelist(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAttributelist(this);
else return visitor.visitChildren(this);
}
}
public final AttributelistContext attributelist() throws RecognitionException {
return attributelist(0);
}
private AttributelistContext attributelist(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
AttributelistContext _localctx = new AttributelistContext(_ctx, _parentState);
AttributelistContext _prevctx = _localctx;
int _startState = 212;
enterRecursionRule(_localctx, 212, RULE_attributelist, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1579);
switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) {
case 1:
{
setState(1574);
switch ( getInterpreter().adaptivePredict(_input,158,_ctx) ) {
case 1:
{
setState(1573);
attribute();
}
break;
}
}
break;
case 2:
{
setState(1576);
attribute();
setState(1577);
match(Ellipsis);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1593);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,162,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1591);
switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) {
case 1:
{
_localctx = new AttributelistContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_attributelist);
setState(1581);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(1582);
match(Comma);
setState(1584);
switch ( getInterpreter().adaptivePredict(_input,160,_ctx) ) {
case 1:
{
setState(1583);
attribute();
}
break;
}
}
break;
case 2:
{
_localctx = new AttributelistContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_attributelist);
setState(1586);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1587);
match(Comma);
setState(1588);
attribute();
setState(1589);
match(Ellipsis);
}
break;
}
}
}
setState(1595);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,162,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class AttributeContext extends ParserRuleContext {
public AttributetokenContext attributetoken() {
return getRuleContext(AttributetokenContext.class,0);
}
public AttributeargumentclauseContext attributeargumentclause() {
return getRuleContext(AttributeargumentclauseContext.class,0);
}
public AttributeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attribute; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttribute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttribute(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAttribute(this);
else return visitor.visitChildren(this);
}
}
public final AttributeContext attribute() throws RecognitionException {
AttributeContext _localctx = new AttributeContext(_ctx, getState());
enterRule(_localctx, 214, RULE_attribute);
try {
enterOuterAlt(_localctx, 1);
{
setState(1596);
attributetoken();
setState(1598);
switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) {
case 1:
{
setState(1597);
attributeargumentclause();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributetokenContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public AttributescopedtokenContext attributescopedtoken() {
return getRuleContext(AttributescopedtokenContext.class,0);
}
public AttributetokenContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributetoken; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttributetoken(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttributetoken(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAttributetoken(this);
else return visitor.visitChildren(this);
}
}
public final AttributetokenContext attributetoken() throws RecognitionException {
AttributetokenContext _localctx = new AttributetokenContext(_ctx, getState());
enterRule(_localctx, 216, RULE_attributetoken);
try {
setState(1602);
switch ( getInterpreter().adaptivePredict(_input,164,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1600);
match(Identifier);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1601);
attributescopedtoken();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributescopedtokenContext extends ParserRuleContext {
public AttributenamespaceContext attributenamespace() {
return getRuleContext(AttributenamespaceContext.class,0);
}
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public AttributescopedtokenContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributescopedtoken; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttributescopedtoken(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttributescopedtoken(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAttributescopedtoken(this);
else return visitor.visitChildren(this);
}
}
public final AttributescopedtokenContext attributescopedtoken() throws RecognitionException {
AttributescopedtokenContext _localctx = new AttributescopedtokenContext(_ctx, getState());
enterRule(_localctx, 218, RULE_attributescopedtoken);
try {
enterOuterAlt(_localctx, 1);
{
setState(1604);
attributenamespace();
setState(1605);
match(Doublecolon);
setState(1606);
match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributenamespaceContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public AttributenamespaceContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributenamespace; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttributenamespace(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttributenamespace(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAttributenamespace(this);
else return visitor.visitChildren(this);
}
}
public final AttributenamespaceContext attributenamespace() throws RecognitionException {
AttributenamespaceContext _localctx = new AttributenamespaceContext(_ctx, getState());
enterRule(_localctx, 220, RULE_attributenamespace);
try {
enterOuterAlt(_localctx, 1);
{
setState(1608);
match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AttributeargumentclauseContext extends ParserRuleContext {
public BalancedtokenseqContext balancedtokenseq() {
return getRuleContext(BalancedtokenseqContext.class,0);
}
public AttributeargumentclauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_attributeargumentclause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAttributeargumentclause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAttributeargumentclause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAttributeargumentclause(this);
else return visitor.visitChildren(this);
}
}
public final AttributeargumentclauseContext attributeargumentclause() throws RecognitionException {
AttributeargumentclauseContext _localctx = new AttributeargumentclauseContext(_ctx, getState());
enterRule(_localctx, 222, RULE_attributeargumentclause);
try {
enterOuterAlt(_localctx, 1);
{
setState(1610);
match(LeftParen);
setState(1611);
balancedtokenseq(0);
setState(1612);
match(RightParen);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BalancedtokenseqContext extends ParserRuleContext {
public BalancedtokenContext balancedtoken() {
return getRuleContext(BalancedtokenContext.class,0);
}
public BalancedtokenseqContext balancedtokenseq() {
return getRuleContext(BalancedtokenseqContext.class,0);
}
public BalancedtokenseqContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_balancedtokenseq; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBalancedtokenseq(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBalancedtokenseq(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitBalancedtokenseq(this);
else return visitor.visitChildren(this);
}
}
public final BalancedtokenseqContext balancedtokenseq() throws RecognitionException {
return balancedtokenseq(0);
}
private BalancedtokenseqContext balancedtokenseq(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
BalancedtokenseqContext _localctx = new BalancedtokenseqContext(_ctx, _parentState);
BalancedtokenseqContext _prevctx = _localctx;
int _startState = 224;
enterRecursionRule(_localctx, 224, RULE_balancedtokenseq, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1616);
switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) {
case 1:
{
setState(1615);
balancedtoken();
}
break;
}
}
_ctx.stop = _input.LT(-1);
setState(1622);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,166,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new BalancedtokenseqContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_balancedtokenseq);
setState(1618);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1619);
balancedtoken();
}
}
}
setState(1624);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,166,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class BalancedtokenContext extends ParserRuleContext {
public BalancedtokenseqContext balancedtokenseq() {
return getRuleContext(BalancedtokenseqContext.class,0);
}
public BalancedtokenContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_balancedtoken; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBalancedtoken(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBalancedtoken(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitBalancedtoken(this);
else return visitor.visitChildren(this);
}
}
public final BalancedtokenContext balancedtoken() throws RecognitionException {
BalancedtokenContext _localctx = new BalancedtokenContext(_ctx, getState());
enterRule(_localctx, 226, RULE_balancedtoken);
try {
setState(1637);
switch (_input.LA(1)) {
case LeftParen:
enterOuterAlt(_localctx, 1);
{
setState(1625);
match(LeftParen);
setState(1626);
balancedtokenseq(0);
setState(1627);
match(RightParen);
}
break;
case LeftBracket:
enterOuterAlt(_localctx, 2);
{
setState(1629);
match(LeftBracket);
setState(1630);
balancedtokenseq(0);
setState(1631);
match(RightBracket);
}
break;
case LeftBrace:
enterOuterAlt(_localctx, 3);
{
setState(1633);
match(LeftBrace);
setState(1634);
balancedtokenseq(0);
setState(1635);
match(RightBrace);
}
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 InitdeclaratorlistContext extends ParserRuleContext {
public InitdeclaratorContext initdeclarator() {
return getRuleContext(InitdeclaratorContext.class,0);
}
public InitdeclaratorlistContext initdeclaratorlist() {
return getRuleContext(InitdeclaratorlistContext.class,0);
}
public InitdeclaratorlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_initdeclaratorlist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInitdeclaratorlist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInitdeclaratorlist(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitInitdeclaratorlist(this);
else return visitor.visitChildren(this);
}
}
public final InitdeclaratorlistContext initdeclaratorlist() throws RecognitionException {
return initdeclaratorlist(0);
}
private InitdeclaratorlistContext initdeclaratorlist(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
InitdeclaratorlistContext _localctx = new InitdeclaratorlistContext(_ctx, _parentState);
InitdeclaratorlistContext _prevctx = _localctx;
int _startState = 228;
enterRecursionRule(_localctx, 228, RULE_initdeclaratorlist, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1640);
initdeclarator();
}
_ctx.stop = _input.LT(-1);
setState(1647);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,168,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new InitdeclaratorlistContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_initdeclaratorlist);
setState(1642);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1643);
match(Comma);
setState(1644);
initdeclarator();
}
}
}
setState(1649);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,168,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class InitdeclaratorContext extends ParserRuleContext {
public DeclaratorContext declarator() {
return getRuleContext(DeclaratorContext.class,0);
}
public InitializerContext initializer() {
return getRuleContext(InitializerContext.class,0);
}
public InitdeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_initdeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInitdeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInitdeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitInitdeclarator(this);
else return visitor.visitChildren(this);
}
}
public final InitdeclaratorContext initdeclarator() throws RecognitionException {
InitdeclaratorContext _localctx = new InitdeclaratorContext(_ctx, getState());
enterRule(_localctx, 230, RULE_initdeclarator);
try {
enterOuterAlt(_localctx, 1);
{
setState(1650);
declarator();
setState(1652);
switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) {
case 1:
{
setState(1651);
initializer();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclaratorContext extends ParserRuleContext {
public PtrdeclaratorContext ptrdeclarator() {
return getRuleContext(PtrdeclaratorContext.class,0);
}
public NoptrdeclaratorContext noptrdeclarator() {
return getRuleContext(NoptrdeclaratorContext.class,0);
}
public ParametersandqualifiersContext parametersandqualifiers() {
return getRuleContext(ParametersandqualifiersContext.class,0);
}
public TrailingreturntypeContext trailingreturntype() {
return getRuleContext(TrailingreturntypeContext.class,0);
}
public DeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitDeclarator(this);
else return visitor.visitChildren(this);
}
}
public final DeclaratorContext declarator() throws RecognitionException {
DeclaratorContext _localctx = new DeclaratorContext(_ctx, getState());
enterRule(_localctx, 232, RULE_declarator);
try {
setState(1659);
switch ( getInterpreter().adaptivePredict(_input,170,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1654);
ptrdeclarator();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1655);
noptrdeclarator(0);
setState(1656);
parametersandqualifiers();
setState(1657);
trailingreturntype();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PtrdeclaratorContext extends ParserRuleContext {
public NoptrdeclaratorContext noptrdeclarator() {
return getRuleContext(NoptrdeclaratorContext.class,0);
}
public PtroperatorContext ptroperator() {
return getRuleContext(PtroperatorContext.class,0);
}
public PtrdeclaratorContext ptrdeclarator() {
return getRuleContext(PtrdeclaratorContext.class,0);
}
public PtrdeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ptrdeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPtrdeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPtrdeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitPtrdeclarator(this);
else return visitor.visitChildren(this);
}
}
public final PtrdeclaratorContext ptrdeclarator() throws RecognitionException {
PtrdeclaratorContext _localctx = new PtrdeclaratorContext(_ctx, getState());
enterRule(_localctx, 234, RULE_ptrdeclarator);
try {
setState(1665);
switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1661);
noptrdeclarator(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1662);
ptroperator();
setState(1663);
ptrdeclarator();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NoptrdeclaratorContext extends ParserRuleContext {
public DeclaratoridContext declaratorid() {
return getRuleContext(DeclaratoridContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public PtrdeclaratorContext ptrdeclarator() {
return getRuleContext(PtrdeclaratorContext.class,0);
}
public NoptrdeclaratorContext noptrdeclarator() {
return getRuleContext(NoptrdeclaratorContext.class,0);
}
public ParametersandqualifiersContext parametersandqualifiers() {
return getRuleContext(ParametersandqualifiersContext.class,0);
}
public ConstantexpressionContext constantexpression() {
return getRuleContext(ConstantexpressionContext.class,0);
}
public NoptrdeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_noptrdeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNoptrdeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNoptrdeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNoptrdeclarator(this);
else return visitor.visitChildren(this);
}
}
public final NoptrdeclaratorContext noptrdeclarator() throws RecognitionException {
return noptrdeclarator(0);
}
private NoptrdeclaratorContext noptrdeclarator(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
NoptrdeclaratorContext _localctx = new NoptrdeclaratorContext(_ctx, _parentState);
NoptrdeclaratorContext _prevctx = _localctx;
int _startState = 236;
enterRecursionRule(_localctx, 236, RULE_noptrdeclarator, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1676);
switch (_input.LA(1)) {
case Decltype:
case Operator:
case Tilde:
case Doublecolon:
case Ellipsis:
case Identifier:
{
setState(1668);
declaratorid();
setState(1670);
switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) {
case 1:
{
setState(1669);
attributespecifierseq(0);
}
break;
}
}
break;
case LeftParen:
{
setState(1672);
match(LeftParen);
setState(1673);
ptrdeclarator();
setState(1674);
match(RightParen);
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(1691);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,177,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1689);
switch ( getInterpreter().adaptivePredict(_input,176,_ctx) ) {
case 1:
{
_localctx = new NoptrdeclaratorContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_noptrdeclarator);
setState(1678);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(1679);
parametersandqualifiers();
}
break;
case 2:
{
_localctx = new NoptrdeclaratorContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_noptrdeclarator);
setState(1680);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1681);
match(LeftBracket);
setState(1683);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << False) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static_cast) | (1L << This))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (True - 65)) | (1L << (Typeid - 65)) | (1L << (Typename - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)) | (1L << (Identifier - 65)) | (1L << (Integerliteral - 65)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(1682);
constantexpression();
}
}
setState(1685);
match(RightBracket);
setState(1687);
switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) {
case 1:
{
setState(1686);
attributespecifierseq(0);
}
break;
}
}
break;
}
}
}
setState(1693);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,177,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ParametersandqualifiersContext extends ParserRuleContext {
public ParameterdeclarationclauseContext parameterdeclarationclause() {
return getRuleContext(ParameterdeclarationclauseContext.class,0);
}
public CvqualifierseqContext cvqualifierseq() {
return getRuleContext(CvqualifierseqContext.class,0);
}
public RefqualifierContext refqualifier() {
return getRuleContext(RefqualifierContext.class,0);
}
public ExceptionspecificationContext exceptionspecification() {
return getRuleContext(ExceptionspecificationContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public ParametersandqualifiersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parametersandqualifiers; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterParametersandqualifiers(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitParametersandqualifiers(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitParametersandqualifiers(this);
else return visitor.visitChildren(this);
}
}
public final ParametersandqualifiersContext parametersandqualifiers() throws RecognitionException {
ParametersandqualifiersContext _localctx = new ParametersandqualifiersContext(_ctx, getState());
enterRule(_localctx, 238, RULE_parametersandqualifiers);
try {
enterOuterAlt(_localctx, 1);
{
setState(1694);
match(LeftParen);
setState(1695);
parameterdeclarationclause();
setState(1696);
match(RightParen);
setState(1698);
switch ( getInterpreter().adaptivePredict(_input,178,_ctx) ) {
case 1:
{
setState(1697);
cvqualifierseq();
}
break;
}
setState(1701);
switch ( getInterpreter().adaptivePredict(_input,179,_ctx) ) {
case 1:
{
setState(1700);
refqualifier();
}
break;
}
setState(1704);
switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) {
case 1:
{
setState(1703);
exceptionspecification();
}
break;
}
setState(1707);
switch ( getInterpreter().adaptivePredict(_input,181,_ctx) ) {
case 1:
{
setState(1706);
attributespecifierseq(0);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TrailingreturntypeContext extends ParserRuleContext {
public TrailingtypespecifierseqContext trailingtypespecifierseq() {
return getRuleContext(TrailingtypespecifierseqContext.class,0);
}
public AbstractdeclaratorContext abstractdeclarator() {
return getRuleContext(AbstractdeclaratorContext.class,0);
}
public TrailingreturntypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_trailingreturntype; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTrailingreturntype(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTrailingreturntype(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTrailingreturntype(this);
else return visitor.visitChildren(this);
}
}
public final TrailingreturntypeContext trailingreturntype() throws RecognitionException {
TrailingreturntypeContext _localctx = new TrailingreturntypeContext(_ctx, getState());
enterRule(_localctx, 240, RULE_trailingreturntype);
try {
enterOuterAlt(_localctx, 1);
{
setState(1709);
match(Arrow);
setState(1710);
trailingtypespecifierseq();
setState(1712);
switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) {
case 1:
{
setState(1711);
abstractdeclarator();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PtroperatorContext extends ParserRuleContext {
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public CvqualifierseqContext cvqualifierseq() {
return getRuleContext(CvqualifierseqContext.class,0);
}
public NestednamespecifierContext nestednamespecifier() {
return getRuleContext(NestednamespecifierContext.class,0);
}
public PtroperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ptroperator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPtroperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPtroperator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitPtroperator(this);
else return visitor.visitChildren(this);
}
}
public final PtroperatorContext ptroperator() throws RecognitionException {
PtroperatorContext _localctx = new PtroperatorContext(_ctx, getState());
enterRule(_localctx, 242, RULE_ptroperator);
try {
setState(1737);
switch (_input.LA(1)) {
case Star:
enterOuterAlt(_localctx, 1);
{
setState(1714);
match(Star);
setState(1716);
switch ( getInterpreter().adaptivePredict(_input,183,_ctx) ) {
case 1:
{
setState(1715);
attributespecifierseq(0);
}
break;
}
setState(1719);
switch ( getInterpreter().adaptivePredict(_input,184,_ctx) ) {
case 1:
{
setState(1718);
cvqualifierseq();
}
break;
}
}
break;
case And:
enterOuterAlt(_localctx, 2);
{
setState(1721);
match(And);
setState(1723);
switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) {
case 1:
{
setState(1722);
attributespecifierseq(0);
}
break;
}
}
break;
case AndAnd:
enterOuterAlt(_localctx, 3);
{
setState(1725);
match(AndAnd);
setState(1727);
switch ( getInterpreter().adaptivePredict(_input,186,_ctx) ) {
case 1:
{
setState(1726);
attributespecifierseq(0);
}
break;
}
}
break;
case Decltype:
case Doublecolon:
case Identifier:
enterOuterAlt(_localctx, 4);
{
setState(1729);
nestednamespecifier(0);
setState(1730);
match(Star);
setState(1732);
switch ( getInterpreter().adaptivePredict(_input,187,_ctx) ) {
case 1:
{
setState(1731);
attributespecifierseq(0);
}
break;
}
setState(1735);
switch ( getInterpreter().adaptivePredict(_input,188,_ctx) ) {
case 1:
{
setState(1734);
cvqualifierseq();
}
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 CvqualifierseqContext extends ParserRuleContext {
public CvqualifierContext cvqualifier() {
return getRuleContext(CvqualifierContext.class,0);
}
public CvqualifierseqContext cvqualifierseq() {
return getRuleContext(CvqualifierseqContext.class,0);
}
public CvqualifierseqContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cvqualifierseq; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCvqualifierseq(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCvqualifierseq(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitCvqualifierseq(this);
else return visitor.visitChildren(this);
}
}
public final CvqualifierseqContext cvqualifierseq() throws RecognitionException {
CvqualifierseqContext _localctx = new CvqualifierseqContext(_ctx, getState());
enterRule(_localctx, 244, RULE_cvqualifierseq);
try {
enterOuterAlt(_localctx, 1);
{
setState(1739);
cvqualifier();
setState(1741);
switch ( getInterpreter().adaptivePredict(_input,190,_ctx) ) {
case 1:
{
setState(1740);
cvqualifierseq();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CvqualifierContext extends ParserRuleContext {
public TerminalNode Const() { return getToken(CPP14Parser.Const, 0); }
public TerminalNode Volatile() { return getToken(CPP14Parser.Volatile, 0); }
public CvqualifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cvqualifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCvqualifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCvqualifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitCvqualifier(this);
else return visitor.visitChildren(this);
}
}
public final CvqualifierContext cvqualifier() throws RecognitionException {
CvqualifierContext _localctx = new CvqualifierContext(_ctx, getState());
enterRule(_localctx, 246, RULE_cvqualifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1743);
_la = _input.LA(1);
if ( !(_la==Const || _la==Volatile) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RefqualifierContext extends ParserRuleContext {
public RefqualifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_refqualifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterRefqualifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitRefqualifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitRefqualifier(this);
else return visitor.visitChildren(this);
}
}
public final RefqualifierContext refqualifier() throws RecognitionException {
RefqualifierContext _localctx = new RefqualifierContext(_ctx, getState());
enterRule(_localctx, 248, RULE_refqualifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1745);
_la = _input.LA(1);
if ( !(_la==And || _la==AndAnd) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclaratoridContext extends ParserRuleContext {
public IdexpressionContext idexpression() {
return getRuleContext(IdexpressionContext.class,0);
}
public DeclaratoridContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declaratorid; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDeclaratorid(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDeclaratorid(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitDeclaratorid(this);
else return visitor.visitChildren(this);
}
}
public final DeclaratoridContext declaratorid() throws RecognitionException {
DeclaratoridContext _localctx = new DeclaratoridContext(_ctx, getState());
enterRule(_localctx, 250, RULE_declaratorid);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1748);
_la = _input.LA(1);
if (_la==Ellipsis) {
{
setState(1747);
match(Ellipsis);
}
}
setState(1750);
idexpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeidContext extends ParserRuleContext {
public TypespecifierseqContext typespecifierseq() {
return getRuleContext(TypespecifierseqContext.class,0);
}
public AbstractdeclaratorContext abstractdeclarator() {
return getRuleContext(AbstractdeclaratorContext.class,0);
}
public TypeidContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeid; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypeid(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypeid(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTypeid(this);
else return visitor.visitChildren(this);
}
}
public final TypeidContext typeid() throws RecognitionException {
TypeidContext _localctx = new TypeidContext(_ctx, getState());
enterRule(_localctx, 252, RULE_typeid);
try {
enterOuterAlt(_localctx, 1);
{
setState(1752);
typespecifierseq();
setState(1754);
switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) {
case 1:
{
setState(1753);
abstractdeclarator();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AbstractdeclaratorContext extends ParserRuleContext {
public PtrabstractdeclaratorContext ptrabstractdeclarator() {
return getRuleContext(PtrabstractdeclaratorContext.class,0);
}
public ParametersandqualifiersContext parametersandqualifiers() {
return getRuleContext(ParametersandqualifiersContext.class,0);
}
public TrailingreturntypeContext trailingreturntype() {
return getRuleContext(TrailingreturntypeContext.class,0);
}
public NoptrabstractdeclaratorContext noptrabstractdeclarator() {
return getRuleContext(NoptrabstractdeclaratorContext.class,0);
}
public AbstractpackdeclaratorContext abstractpackdeclarator() {
return getRuleContext(AbstractpackdeclaratorContext.class,0);
}
public AbstractdeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_abstractdeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAbstractdeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAbstractdeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAbstractdeclarator(this);
else return visitor.visitChildren(this);
}
}
public final AbstractdeclaratorContext abstractdeclarator() throws RecognitionException {
AbstractdeclaratorContext _localctx = new AbstractdeclaratorContext(_ctx, getState());
enterRule(_localctx, 254, RULE_abstractdeclarator);
try {
setState(1764);
switch ( getInterpreter().adaptivePredict(_input,194,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1756);
ptrabstractdeclarator();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1758);
switch ( getInterpreter().adaptivePredict(_input,193,_ctx) ) {
case 1:
{
setState(1757);
noptrabstractdeclarator(0);
}
break;
}
setState(1760);
parametersandqualifiers();
setState(1761);
trailingreturntype();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1763);
abstractpackdeclarator();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PtrabstractdeclaratorContext extends ParserRuleContext {
public NoptrabstractdeclaratorContext noptrabstractdeclarator() {
return getRuleContext(NoptrabstractdeclaratorContext.class,0);
}
public PtroperatorContext ptroperator() {
return getRuleContext(PtroperatorContext.class,0);
}
public PtrabstractdeclaratorContext ptrabstractdeclarator() {
return getRuleContext(PtrabstractdeclaratorContext.class,0);
}
public PtrabstractdeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ptrabstractdeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPtrabstractdeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPtrabstractdeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitPtrabstractdeclarator(this);
else return visitor.visitChildren(this);
}
}
public final PtrabstractdeclaratorContext ptrabstractdeclarator() throws RecognitionException {
PtrabstractdeclaratorContext _localctx = new PtrabstractdeclaratorContext(_ctx, getState());
enterRule(_localctx, 256, RULE_ptrabstractdeclarator);
try {
setState(1771);
switch (_input.LA(1)) {
case LeftParen:
case LeftBracket:
enterOuterAlt(_localctx, 1);
{
setState(1766);
noptrabstractdeclarator(0);
}
break;
case Decltype:
case Star:
case And:
case AndAnd:
case Doublecolon:
case Identifier:
enterOuterAlt(_localctx, 2);
{
setState(1767);
ptroperator();
setState(1769);
switch ( getInterpreter().adaptivePredict(_input,195,_ctx) ) {
case 1:
{
setState(1768);
ptrabstractdeclarator();
}
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 NoptrabstractdeclaratorContext extends ParserRuleContext {
public ParametersandqualifiersContext parametersandqualifiers() {
return getRuleContext(ParametersandqualifiersContext.class,0);
}
public ConstantexpressionContext constantexpression() {
return getRuleContext(ConstantexpressionContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public PtrabstractdeclaratorContext ptrabstractdeclarator() {
return getRuleContext(PtrabstractdeclaratorContext.class,0);
}
public NoptrabstractdeclaratorContext noptrabstractdeclarator() {
return getRuleContext(NoptrabstractdeclaratorContext.class,0);
}
public NoptrabstractdeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_noptrabstractdeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNoptrabstractdeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNoptrabstractdeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNoptrabstractdeclarator(this);
else return visitor.visitChildren(this);
}
}
public final NoptrabstractdeclaratorContext noptrabstractdeclarator() throws RecognitionException {
return noptrabstractdeclarator(0);
}
private NoptrabstractdeclaratorContext noptrabstractdeclarator(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
NoptrabstractdeclaratorContext _localctx = new NoptrabstractdeclaratorContext(_ctx, _parentState);
NoptrabstractdeclaratorContext _prevctx = _localctx;
int _startState = 258;
enterRecursionRule(_localctx, 258, RULE_noptrabstractdeclarator, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(1787);
switch ( getInterpreter().adaptivePredict(_input,199,_ctx) ) {
case 1:
{
setState(1774);
parametersandqualifiers();
}
break;
case 2:
{
setState(1775);
match(LeftBracket);
setState(1777);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << False) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static_cast) | (1L << This))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (True - 65)) | (1L << (Typeid - 65)) | (1L << (Typename - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)) | (1L << (Identifier - 65)) | (1L << (Integerliteral - 65)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(1776);
constantexpression();
}
}
setState(1779);
match(RightBracket);
setState(1781);
switch ( getInterpreter().adaptivePredict(_input,198,_ctx) ) {
case 1:
{
setState(1780);
attributespecifierseq(0);
}
break;
}
}
break;
case 3:
{
setState(1783);
match(LeftParen);
setState(1784);
ptrabstractdeclarator();
setState(1785);
match(RightParen);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(1802);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,203,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1800);
switch ( getInterpreter().adaptivePredict(_input,202,_ctx) ) {
case 1:
{
_localctx = new NoptrabstractdeclaratorContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_noptrabstractdeclarator);
setState(1789);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(1790);
parametersandqualifiers();
}
break;
case 2:
{
_localctx = new NoptrabstractdeclaratorContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_noptrabstractdeclarator);
setState(1791);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(1792);
match(LeftBracket);
setState(1794);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << False) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static_cast) | (1L << This))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (True - 65)) | (1L << (Typeid - 65)) | (1L << (Typename - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)) | (1L << (Identifier - 65)) | (1L << (Integerliteral - 65)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(1793);
constantexpression();
}
}
setState(1796);
match(RightBracket);
setState(1798);
switch ( getInterpreter().adaptivePredict(_input,201,_ctx) ) {
case 1:
{
setState(1797);
attributespecifierseq(0);
}
break;
}
}
break;
}
}
}
setState(1804);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,203,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class AbstractpackdeclaratorContext extends ParserRuleContext {
public NoptrabstractpackdeclaratorContext noptrabstractpackdeclarator() {
return getRuleContext(NoptrabstractpackdeclaratorContext.class,0);
}
public PtroperatorContext ptroperator() {
return getRuleContext(PtroperatorContext.class,0);
}
public AbstractpackdeclaratorContext abstractpackdeclarator() {
return getRuleContext(AbstractpackdeclaratorContext.class,0);
}
public AbstractpackdeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_abstractpackdeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAbstractpackdeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAbstractpackdeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAbstractpackdeclarator(this);
else return visitor.visitChildren(this);
}
}
public final AbstractpackdeclaratorContext abstractpackdeclarator() throws RecognitionException {
AbstractpackdeclaratorContext _localctx = new AbstractpackdeclaratorContext(_ctx, getState());
enterRule(_localctx, 260, RULE_abstractpackdeclarator);
try {
setState(1809);
switch (_input.LA(1)) {
case Ellipsis:
enterOuterAlt(_localctx, 1);
{
setState(1805);
noptrabstractpackdeclarator(0);
}
break;
case Decltype:
case Star:
case And:
case AndAnd:
case Doublecolon:
case Identifier:
enterOuterAlt(_localctx, 2);
{
setState(1806);
ptroperator();
setState(1807);
abstractpackdeclarator();
}
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 NoptrabstractpackdeclaratorContext extends ParserRuleContext {
public NoptrabstractpackdeclaratorContext noptrabstractpackdeclarator() {
return getRuleContext(NoptrabstractpackdeclaratorContext.class,0);
}
public ParametersandqualifiersContext parametersandqualifiers() {
return getRuleContext(ParametersandqualifiersContext.class,0);
}
public ConstantexpressionContext constantexpression() {
return getRuleContext(ConstantexpressionContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public NoptrabstractpackdeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_noptrabstractpackdeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNoptrabstractpackdeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNoptrabstractpackdeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNoptrabstractpackdeclarator(this);
else return visitor.visitChildren(this);
}
}
public final NoptrabstractpackdeclaratorContext noptrabstractpackdeclarator() throws RecognitionException {
return noptrabstractpackdeclarator(0);
}
private NoptrabstractpackdeclaratorContext noptrabstractpackdeclarator(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
NoptrabstractpackdeclaratorContext _localctx = new NoptrabstractpackdeclaratorContext(_ctx, _parentState);
NoptrabstractpackdeclaratorContext _prevctx = _localctx;
int _startState = 262;
enterRecursionRule(_localctx, 262, RULE_noptrabstractpackdeclarator, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1812);
match(Ellipsis);
}
_ctx.stop = _input.LT(-1);
setState(1827);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,208,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(1825);
switch ( getInterpreter().adaptivePredict(_input,207,_ctx) ) {
case 1:
{
_localctx = new NoptrabstractpackdeclaratorContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_noptrabstractpackdeclarator);
setState(1814);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(1815);
parametersandqualifiers();
}
break;
case 2:
{
_localctx = new NoptrabstractpackdeclaratorContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_noptrabstractpackdeclarator);
setState(1816);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(1817);
match(LeftBracket);
setState(1819);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << False) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static_cast) | (1L << This))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (True - 65)) | (1L << (Typeid - 65)) | (1L << (Typename - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)) | (1L << (Identifier - 65)) | (1L << (Integerliteral - 65)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(1818);
constantexpression();
}
}
setState(1821);
match(RightBracket);
setState(1823);
switch ( getInterpreter().adaptivePredict(_input,206,_ctx) ) {
case 1:
{
setState(1822);
attributespecifierseq(0);
}
break;
}
}
break;
}
}
}
setState(1829);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,208,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ParameterdeclarationclauseContext extends ParserRuleContext {
public ParameterdeclarationlistContext parameterdeclarationlist() {
return getRuleContext(ParameterdeclarationlistContext.class,0);
}
public ParameterdeclarationclauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterdeclarationclause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterParameterdeclarationclause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitParameterdeclarationclause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitParameterdeclarationclause(this);
else return visitor.visitChildren(this);
}
}
public final ParameterdeclarationclauseContext parameterdeclarationclause() throws RecognitionException {
ParameterdeclarationclauseContext _localctx = new ParameterdeclarationclauseContext(_ctx, getState());
enterRule(_localctx, 264, RULE_parameterdeclarationclause);
int _la;
try {
setState(1840);
switch ( getInterpreter().adaptivePredict(_input,211,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1831);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignas) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Decltype) | (1L << Double) | (1L << Enum) | (1L << Explicit) | (1L << Extern) | (1L << Float) | (1L << Friend) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << Register) | (1L << Short) | (1L << Signed) | (1L << Static) | (1L << Struct) | (1L << Thread_local))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (Typedef - 67)) | (1L << (Typename - 67)) | (1L << (Union - 67)) | (1L << (Unsigned - 67)) | (1L << (Virtual - 67)) | (1L << (Void - 67)) | (1L << (Volatile - 67)) | (1L << (Wchar - 67)) | (1L << (LeftBracket - 67)) | (1L << (Doublecolon - 67)) | (1L << (Identifier - 67)))) != 0)) {
{
setState(1830);
parameterdeclarationlist(0);
}
}
setState(1834);
_la = _input.LA(1);
if (_la==Ellipsis) {
{
setState(1833);
match(Ellipsis);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1836);
parameterdeclarationlist(0);
setState(1837);
match(Comma);
setState(1838);
match(Ellipsis);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParameterdeclarationlistContext extends ParserRuleContext {
public ParameterdeclarationContext parameterdeclaration() {
return getRuleContext(ParameterdeclarationContext.class,0);
}
public ParameterdeclarationlistContext parameterdeclarationlist() {
return getRuleContext(ParameterdeclarationlistContext.class,0);
}
public ParameterdeclarationlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterdeclarationlist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterParameterdeclarationlist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitParameterdeclarationlist(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitParameterdeclarationlist(this);
else return visitor.visitChildren(this);
}
}
public final ParameterdeclarationlistContext parameterdeclarationlist() throws RecognitionException {
return parameterdeclarationlist(0);
}
private ParameterdeclarationlistContext parameterdeclarationlist(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
ParameterdeclarationlistContext _localctx = new ParameterdeclarationlistContext(_ctx, _parentState);
ParameterdeclarationlistContext _prevctx = _localctx;
int _startState = 266;
enterRecursionRule(_localctx, 266, RULE_parameterdeclarationlist, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1843);
parameterdeclaration();
}
_ctx.stop = _input.LT(-1);
setState(1850);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,212,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new ParameterdeclarationlistContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_parameterdeclarationlist);
setState(1845);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1846);
match(Comma);
setState(1847);
parameterdeclaration();
}
}
}
setState(1852);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,212,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class ParameterdeclarationContext extends ParserRuleContext {
public DeclspecifierseqContext declspecifierseq() {
return getRuleContext(DeclspecifierseqContext.class,0);
}
public DeclaratorContext declarator() {
return getRuleContext(DeclaratorContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public InitializerclauseContext initializerclause() {
return getRuleContext(InitializerclauseContext.class,0);
}
public AbstractdeclaratorContext abstractdeclarator() {
return getRuleContext(AbstractdeclaratorContext.class,0);
}
public ParameterdeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterdeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterParameterdeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitParameterdeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitParameterdeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ParameterdeclarationContext parameterdeclaration() throws RecognitionException {
ParameterdeclarationContext _localctx = new ParameterdeclarationContext(_ctx, getState());
enterRule(_localctx, 268, RULE_parameterdeclaration);
int _la;
try {
setState(1884);
switch ( getInterpreter().adaptivePredict(_input,219,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1854);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1853);
attributespecifierseq(0);
}
}
setState(1856);
declspecifierseq();
setState(1857);
declarator();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1860);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1859);
attributespecifierseq(0);
}
}
setState(1862);
declspecifierseq();
setState(1863);
declarator();
setState(1864);
match(Assign);
setState(1865);
initializerclause();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1868);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1867);
attributespecifierseq(0);
}
}
setState(1870);
declspecifierseq();
setState(1872);
switch ( getInterpreter().adaptivePredict(_input,216,_ctx) ) {
case 1:
{
setState(1871);
abstractdeclarator();
}
break;
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1875);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1874);
attributespecifierseq(0);
}
}
setState(1877);
declspecifierseq();
setState(1879);
_la = _input.LA(1);
if (_la==Decltype || ((((_la - 78)) & ~0x3f) == 0 && ((1L << (_la - 78)) & ((1L << (LeftParen - 78)) | (1L << (LeftBracket - 78)) | (1L << (Star - 78)) | (1L << (And - 78)) | (1L << (AndAnd - 78)) | (1L << (Doublecolon - 78)) | (1L << (Ellipsis - 78)) | (1L << (Identifier - 78)))) != 0)) {
{
setState(1878);
abstractdeclarator();
}
}
setState(1881);
match(Assign);
setState(1882);
initializerclause();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctiondefinitionContext extends ParserRuleContext {
public DeclaratorContext declarator() {
return getRuleContext(DeclaratorContext.class,0);
}
public FunctionbodyContext functionbody() {
return getRuleContext(FunctionbodyContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public DeclspecifierseqContext declspecifierseq() {
return getRuleContext(DeclspecifierseqContext.class,0);
}
public VirtspecifierseqContext virtspecifierseq() {
return getRuleContext(VirtspecifierseqContext.class,0);
}
public FunctiondefinitionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functiondefinition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterFunctiondefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitFunctiondefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitFunctiondefinition(this);
else return visitor.visitChildren(this);
}
}
public final FunctiondefinitionContext functiondefinition() throws RecognitionException {
FunctiondefinitionContext _localctx = new FunctiondefinitionContext(_ctx, getState());
enterRule(_localctx, 270, RULE_functiondefinition);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1887);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1886);
attributespecifierseq(0);
}
}
setState(1890);
switch ( getInterpreter().adaptivePredict(_input,221,_ctx) ) {
case 1:
{
setState(1889);
declspecifierseq();
}
break;
}
setState(1892);
declarator();
setState(1894);
_la = _input.LA(1);
if (_la==Final || _la==Override) {
{
setState(1893);
virtspecifierseq(0);
}
}
setState(1896);
functionbody();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctionbodyContext extends ParserRuleContext {
public CompoundstatementContext compoundstatement() {
return getRuleContext(CompoundstatementContext.class,0);
}
public CtorinitializerContext ctorinitializer() {
return getRuleContext(CtorinitializerContext.class,0);
}
public FunctiontryblockContext functiontryblock() {
return getRuleContext(FunctiontryblockContext.class,0);
}
public TerminalNode Default() { return getToken(CPP14Parser.Default, 0); }
public TerminalNode Delete() { return getToken(CPP14Parser.Delete, 0); }
public FunctionbodyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functionbody; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterFunctionbody(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitFunctionbody(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitFunctionbody(this);
else return visitor.visitChildren(this);
}
}
public final FunctionbodyContext functionbody() throws RecognitionException {
FunctionbodyContext _localctx = new FunctionbodyContext(_ctx, getState());
enterRule(_localctx, 272, RULE_functionbody);
int _la;
try {
setState(1909);
switch ( getInterpreter().adaptivePredict(_input,224,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1899);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(1898);
ctorinitializer();
}
}
setState(1901);
compoundstatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1902);
functiontryblock();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(1903);
match(Assign);
setState(1904);
match(Default);
setState(1905);
match(Semi);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(1906);
match(Assign);
setState(1907);
match(Delete);
setState(1908);
match(Semi);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InitializerContext extends ParserRuleContext {
public BraceorequalinitializerContext braceorequalinitializer() {
return getRuleContext(BraceorequalinitializerContext.class,0);
}
public ExpressionlistContext expressionlist() {
return getRuleContext(ExpressionlistContext.class,0);
}
public InitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_initializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInitializer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitInitializer(this);
else return visitor.visitChildren(this);
}
}
public final InitializerContext initializer() throws RecognitionException {
InitializerContext _localctx = new InitializerContext(_ctx, getState());
enterRule(_localctx, 274, RULE_initializer);
try {
setState(1916);
switch (_input.LA(1)) {
case LeftBrace:
case Assign:
enterOuterAlt(_localctx, 1);
{
setState(1911);
braceorequalinitializer();
}
break;
case LeftParen:
enterOuterAlt(_localctx, 2);
{
setState(1912);
match(LeftParen);
setState(1913);
expressionlist();
setState(1914);
match(RightParen);
}
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 BraceorequalinitializerContext extends ParserRuleContext {
public InitializerclauseContext initializerclause() {
return getRuleContext(InitializerclauseContext.class,0);
}
public BracedinitlistContext bracedinitlist() {
return getRuleContext(BracedinitlistContext.class,0);
}
public BraceorequalinitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_braceorequalinitializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBraceorequalinitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBraceorequalinitializer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitBraceorequalinitializer(this);
else return visitor.visitChildren(this);
}
}
public final BraceorequalinitializerContext braceorequalinitializer() throws RecognitionException {
BraceorequalinitializerContext _localctx = new BraceorequalinitializerContext(_ctx, getState());
enterRule(_localctx, 276, RULE_braceorequalinitializer);
try {
setState(1921);
switch (_input.LA(1)) {
case Assign:
enterOuterAlt(_localctx, 1);
{
setState(1918);
match(Assign);
setState(1919);
initializerclause();
}
break;
case LeftBrace:
enterOuterAlt(_localctx, 2);
{
setState(1920);
bracedinitlist();
}
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 InitializerclauseContext extends ParserRuleContext {
public AssignmentexpressionContext assignmentexpression() {
return getRuleContext(AssignmentexpressionContext.class,0);
}
public BracedinitlistContext bracedinitlist() {
return getRuleContext(BracedinitlistContext.class,0);
}
public InitializerclauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_initializerclause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInitializerclause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInitializerclause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitInitializerclause(this);
else return visitor.visitChildren(this);
}
}
public final InitializerclauseContext initializerclause() throws RecognitionException {
InitializerclauseContext _localctx = new InitializerclauseContext(_ctx, getState());
enterRule(_localctx, 278, RULE_initializerclause);
try {
setState(1925);
switch (_input.LA(1)) {
case Alignof:
case Auto:
case Bool:
case Char:
case Char16:
case Char32:
case Const_cast:
case Decltype:
case Delete:
case Double:
case Dynamic_cast:
case False:
case Float:
case Int:
case Long:
case New:
case Noexcept:
case Nullptr:
case Operator:
case Reinterpret_cast:
case Short:
case Signed:
case Sizeof:
case Static_cast:
case This:
case Throw:
case True:
case Typeid:
case Typename:
case Unsigned:
case Void:
case Wchar:
case LeftParen:
case LeftBracket:
case Plus:
case Minus:
case Star:
case And:
case Or:
case Tilde:
case Not:
case PlusPlus:
case MinusMinus:
case Doublecolon:
case Identifier:
case Integerliteral:
case Characterliteral:
case Floatingliteral:
case Stringliteral:
case Userdefinedintegerliteral:
case Userdefinedfloatingliteral:
case Userdefinedstringliteral:
case Userdefinedcharacterliteral:
enterOuterAlt(_localctx, 1);
{
setState(1923);
assignmentexpression();
}
break;
case LeftBrace:
enterOuterAlt(_localctx, 2);
{
setState(1924);
bracedinitlist();
}
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 InitializerlistContext extends ParserRuleContext {
public InitializerclauseContext initializerclause() {
return getRuleContext(InitializerclauseContext.class,0);
}
public InitializerlistContext initializerlist() {
return getRuleContext(InitializerlistContext.class,0);
}
public InitializerlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_initializerlist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterInitializerlist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitInitializerlist(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitInitializerlist(this);
else return visitor.visitChildren(this);
}
}
public final InitializerlistContext initializerlist() throws RecognitionException {
return initializerlist(0);
}
private InitializerlistContext initializerlist(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
InitializerlistContext _localctx = new InitializerlistContext(_ctx, _parentState);
InitializerlistContext _prevctx = _localctx;
int _startState = 280;
enterRecursionRule(_localctx, 280, RULE_initializerlist, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(1928);
initializerclause();
setState(1930);
switch ( getInterpreter().adaptivePredict(_input,228,_ctx) ) {
case 1:
{
setState(1929);
match(Ellipsis);
}
break;
}
}
_ctx.stop = _input.LT(-1);
setState(1940);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,230,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new InitializerlistContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_initializerlist);
setState(1932);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(1933);
match(Comma);
setState(1934);
initializerclause();
setState(1936);
switch ( getInterpreter().adaptivePredict(_input,229,_ctx) ) {
case 1:
{
setState(1935);
match(Ellipsis);
}
break;
}
}
}
}
setState(1942);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,230,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class BracedinitlistContext extends ParserRuleContext {
public InitializerlistContext initializerlist() {
return getRuleContext(InitializerlistContext.class,0);
}
public BracedinitlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bracedinitlist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBracedinitlist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBracedinitlist(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitBracedinitlist(this);
else return visitor.visitChildren(this);
}
}
public final BracedinitlistContext bracedinitlist() throws RecognitionException {
BracedinitlistContext _localctx = new BracedinitlistContext(_ctx, getState());
enterRule(_localctx, 282, RULE_bracedinitlist);
int _la;
try {
setState(1952);
switch ( getInterpreter().adaptivePredict(_input,232,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1943);
match(LeftBrace);
setState(1944);
initializerlist(0);
setState(1946);
_la = _input.LA(1);
if (_la==Comma) {
{
setState(1945);
match(Comma);
}
}
setState(1948);
match(RightBrace);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1950);
match(LeftBrace);
setState(1951);
match(RightBrace);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassnameContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public SimpletemplateidContext simpletemplateid() {
return getRuleContext(SimpletemplateidContext.class,0);
}
public ClassnameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classname; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterClassname(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitClassname(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitClassname(this);
else return visitor.visitChildren(this);
}
}
public final ClassnameContext classname() throws RecognitionException {
ClassnameContext _localctx = new ClassnameContext(_ctx, getState());
enterRule(_localctx, 284, RULE_classname);
try {
setState(1956);
switch ( getInterpreter().adaptivePredict(_input,233,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1954);
match(Identifier);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1955);
simpletemplateid();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassspecifierContext extends ParserRuleContext {
public ClassheadContext classhead() {
return getRuleContext(ClassheadContext.class,0);
}
public MemberspecificationContext memberspecification() {
return getRuleContext(MemberspecificationContext.class,0);
}
public ClassspecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classspecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterClassspecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitClassspecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitClassspecifier(this);
else return visitor.visitChildren(this);
}
}
public final ClassspecifierContext classspecifier() throws RecognitionException {
ClassspecifierContext _localctx = new ClassspecifierContext(_ctx, getState());
enterRule(_localctx, 286, RULE_classspecifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1958);
classhead();
setState(1959);
match(LeftBrace);
setState(1961);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignas) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Decltype) | (1L << Double) | (1L << Enum) | (1L << Explicit) | (1L << Extern) | (1L << Float) | (1L << Friend) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << Operator) | (1L << Private) | (1L << Protected) | (1L << Public) | (1L << Register) | (1L << Short) | (1L << Signed) | (1L << Static) | (1L << Static_assert) | (1L << Struct) | (1L << Template) | (1L << Thread_local))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (Typedef - 67)) | (1L << (Typename - 67)) | (1L << (Union - 67)) | (1L << (Unsigned - 67)) | (1L << (Using - 67)) | (1L << (Virtual - 67)) | (1L << (Void - 67)) | (1L << (Volatile - 67)) | (1L << (Wchar - 67)) | (1L << (LeftParen - 67)) | (1L << (LeftBracket - 67)) | (1L << (Star - 67)) | (1L << (And - 67)) | (1L << (Tilde - 67)) | (1L << (AndAnd - 67)) | (1L << (Colon - 67)) | (1L << (Doublecolon - 67)) | (1L << (Semi - 67)) | (1L << (Ellipsis - 67)) | (1L << (Identifier - 67)))) != 0)) {
{
setState(1960);
memberspecification();
}
}
setState(1963);
match(RightBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassheadContext extends ParserRuleContext {
public ClasskeyContext classkey() {
return getRuleContext(ClasskeyContext.class,0);
}
public ClassheadnameContext classheadname() {
return getRuleContext(ClassheadnameContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public ClassvirtspecifierContext classvirtspecifier() {
return getRuleContext(ClassvirtspecifierContext.class,0);
}
public BaseclauseContext baseclause() {
return getRuleContext(BaseclauseContext.class,0);
}
public ClassheadContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classhead; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterClasshead(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitClasshead(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitClasshead(this);
else return visitor.visitChildren(this);
}
}
public final ClassheadContext classhead() throws RecognitionException {
ClassheadContext _localctx = new ClassheadContext(_ctx, getState());
enterRule(_localctx, 288, RULE_classhead);
int _la;
try {
setState(1983);
switch ( getInterpreter().adaptivePredict(_input,240,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1965);
classkey();
setState(1967);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1966);
attributespecifierseq(0);
}
}
setState(1969);
classheadname();
setState(1971);
_la = _input.LA(1);
if (_la==Final) {
{
setState(1970);
classvirtspecifier();
}
}
setState(1974);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(1973);
baseclause();
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1976);
classkey();
setState(1978);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(1977);
attributespecifierseq(0);
}
}
setState(1981);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(1980);
baseclause();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassheadnameContext extends ParserRuleContext {
public ClassnameContext classname() {
return getRuleContext(ClassnameContext.class,0);
}
public NestednamespecifierContext nestednamespecifier() {
return getRuleContext(NestednamespecifierContext.class,0);
}
public ClassheadnameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classheadname; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterClassheadname(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitClassheadname(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitClassheadname(this);
else return visitor.visitChildren(this);
}
}
public final ClassheadnameContext classheadname() throws RecognitionException {
ClassheadnameContext _localctx = new ClassheadnameContext(_ctx, getState());
enterRule(_localctx, 290, RULE_classheadname);
try {
enterOuterAlt(_localctx, 1);
{
setState(1986);
switch ( getInterpreter().adaptivePredict(_input,241,_ctx) ) {
case 1:
{
setState(1985);
nestednamespecifier(0);
}
break;
}
setState(1988);
classname();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassvirtspecifierContext extends ParserRuleContext {
public TerminalNode Final() { return getToken(CPP14Parser.Final, 0); }
public ClassvirtspecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classvirtspecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterClassvirtspecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitClassvirtspecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitClassvirtspecifier(this);
else return visitor.visitChildren(this);
}
}
public final ClassvirtspecifierContext classvirtspecifier() throws RecognitionException {
ClassvirtspecifierContext _localctx = new ClassvirtspecifierContext(_ctx, getState());
enterRule(_localctx, 292, RULE_classvirtspecifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(1990);
match(Final);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClasskeyContext extends ParserRuleContext {
public TerminalNode Class() { return getToken(CPP14Parser.Class, 0); }
public TerminalNode Struct() { return getToken(CPP14Parser.Struct, 0); }
public TerminalNode Union() { return getToken(CPP14Parser.Union, 0); }
public ClasskeyContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classkey; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterClasskey(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitClasskey(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitClasskey(this);
else return visitor.visitChildren(this);
}
}
public final ClasskeyContext classkey() throws RecognitionException {
ClasskeyContext _localctx = new ClasskeyContext(_ctx, getState());
enterRule(_localctx, 294, RULE_classkey);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1992);
_la = _input.LA(1);
if ( !(((((_la - 14)) & ~0x3f) == 0 && ((1L << (_la - 14)) & ((1L << (Class - 14)) | (1L << (Struct - 14)) | (1L << (Union - 14)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MemberspecificationContext extends ParserRuleContext {
public MemberdeclarationContext memberdeclaration() {
return getRuleContext(MemberdeclarationContext.class,0);
}
public MemberspecificationContext memberspecification() {
return getRuleContext(MemberspecificationContext.class,0);
}
public AccessspecifierContext accessspecifier() {
return getRuleContext(AccessspecifierContext.class,0);
}
public MemberspecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_memberspecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterMemberspecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitMemberspecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitMemberspecification(this);
else return visitor.visitChildren(this);
}
}
public final MemberspecificationContext memberspecification() throws RecognitionException {
MemberspecificationContext _localctx = new MemberspecificationContext(_ctx, getState());
enterRule(_localctx, 296, RULE_memberspecification);
int _la;
try {
setState(2003);
switch (_input.LA(1)) {
case Alignas:
case Auto:
case Bool:
case Char:
case Char16:
case Char32:
case Class:
case Const:
case Constexpr:
case Decltype:
case Double:
case Enum:
case Explicit:
case Extern:
case Float:
case Friend:
case Inline:
case Int:
case Long:
case Mutable:
case Operator:
case Register:
case Short:
case Signed:
case Static:
case Static_assert:
case Struct:
case Template:
case Thread_local:
case Typedef:
case Typename:
case Union:
case Unsigned:
case Using:
case Virtual:
case Void:
case Volatile:
case Wchar:
case LeftParen:
case LeftBracket:
case Star:
case And:
case Tilde:
case AndAnd:
case Colon:
case Doublecolon:
case Semi:
case Ellipsis:
case Identifier:
enterOuterAlt(_localctx, 1);
{
setState(1994);
memberdeclaration();
setState(1996);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignas) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Decltype) | (1L << Double) | (1L << Enum) | (1L << Explicit) | (1L << Extern) | (1L << Float) | (1L << Friend) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << Operator) | (1L << Private) | (1L << Protected) | (1L << Public) | (1L << Register) | (1L << Short) | (1L << Signed) | (1L << Static) | (1L << Static_assert) | (1L << Struct) | (1L << Template) | (1L << Thread_local))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (Typedef - 67)) | (1L << (Typename - 67)) | (1L << (Union - 67)) | (1L << (Unsigned - 67)) | (1L << (Using - 67)) | (1L << (Virtual - 67)) | (1L << (Void - 67)) | (1L << (Volatile - 67)) | (1L << (Wchar - 67)) | (1L << (LeftParen - 67)) | (1L << (LeftBracket - 67)) | (1L << (Star - 67)) | (1L << (And - 67)) | (1L << (Tilde - 67)) | (1L << (AndAnd - 67)) | (1L << (Colon - 67)) | (1L << (Doublecolon - 67)) | (1L << (Semi - 67)) | (1L << (Ellipsis - 67)) | (1L << (Identifier - 67)))) != 0)) {
{
setState(1995);
memberspecification();
}
}
}
break;
case Private:
case Protected:
case Public:
enterOuterAlt(_localctx, 2);
{
setState(1998);
accessspecifier();
setState(1999);
match(Colon);
setState(2001);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignas) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Decltype) | (1L << Double) | (1L << Enum) | (1L << Explicit) | (1L << Extern) | (1L << Float) | (1L << Friend) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << Operator) | (1L << Private) | (1L << Protected) | (1L << Public) | (1L << Register) | (1L << Short) | (1L << Signed) | (1L << Static) | (1L << Static_assert) | (1L << Struct) | (1L << Template) | (1L << Thread_local))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (Typedef - 67)) | (1L << (Typename - 67)) | (1L << (Union - 67)) | (1L << (Unsigned - 67)) | (1L << (Using - 67)) | (1L << (Virtual - 67)) | (1L << (Void - 67)) | (1L << (Volatile - 67)) | (1L << (Wchar - 67)) | (1L << (LeftParen - 67)) | (1L << (LeftBracket - 67)) | (1L << (Star - 67)) | (1L << (And - 67)) | (1L << (Tilde - 67)) | (1L << (AndAnd - 67)) | (1L << (Colon - 67)) | (1L << (Doublecolon - 67)) | (1L << (Semi - 67)) | (1L << (Ellipsis - 67)) | (1L << (Identifier - 67)))) != 0)) {
{
setState(2000);
memberspecification();
}
}
}
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 MemberdeclarationContext extends ParserRuleContext {
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public DeclspecifierseqContext declspecifierseq() {
return getRuleContext(DeclspecifierseqContext.class,0);
}
public MemberdeclaratorlistContext memberdeclaratorlist() {
return getRuleContext(MemberdeclaratorlistContext.class,0);
}
public FunctiondefinitionContext functiondefinition() {
return getRuleContext(FunctiondefinitionContext.class,0);
}
public UsingdeclarationContext usingdeclaration() {
return getRuleContext(UsingdeclarationContext.class,0);
}
public Static_assertdeclarationContext static_assertdeclaration() {
return getRuleContext(Static_assertdeclarationContext.class,0);
}
public TemplatedeclarationContext templatedeclaration() {
return getRuleContext(TemplatedeclarationContext.class,0);
}
public AliasdeclarationContext aliasdeclaration() {
return getRuleContext(AliasdeclarationContext.class,0);
}
public EmptydeclarationContext emptydeclaration() {
return getRuleContext(EmptydeclarationContext.class,0);
}
public MemberdeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_memberdeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterMemberdeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitMemberdeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitMemberdeclaration(this);
else return visitor.visitChildren(this);
}
}
public final MemberdeclarationContext memberdeclaration() throws RecognitionException {
MemberdeclarationContext _localctx = new MemberdeclarationContext(_ctx, getState());
enterRule(_localctx, 298, RULE_memberdeclaration);
int _la;
try {
setState(2021);
switch ( getInterpreter().adaptivePredict(_input,248,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2006);
switch ( getInterpreter().adaptivePredict(_input,245,_ctx) ) {
case 1:
{
setState(2005);
attributespecifierseq(0);
}
break;
}
setState(2009);
switch ( getInterpreter().adaptivePredict(_input,246,_ctx) ) {
case 1:
{
setState(2008);
declspecifierseq();
}
break;
}
setState(2012);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignas) | (1L << Decltype) | (1L << Operator))) != 0) || ((((_la - 78)) & ~0x3f) == 0 && ((1L << (_la - 78)) & ((1L << (LeftParen - 78)) | (1L << (LeftBracket - 78)) | (1L << (Star - 78)) | (1L << (And - 78)) | (1L << (Tilde - 78)) | (1L << (AndAnd - 78)) | (1L << (Colon - 78)) | (1L << (Doublecolon - 78)) | (1L << (Ellipsis - 78)) | (1L << (Identifier - 78)))) != 0)) {
{
setState(2011);
memberdeclaratorlist(0);
}
}
setState(2014);
match(Semi);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2015);
functiondefinition();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2016);
usingdeclaration();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2017);
static_assertdeclaration();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2018);
templatedeclaration();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2019);
aliasdeclaration();
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2020);
emptydeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MemberdeclaratorlistContext extends ParserRuleContext {
public MemberdeclaratorContext memberdeclarator() {
return getRuleContext(MemberdeclaratorContext.class,0);
}
public MemberdeclaratorlistContext memberdeclaratorlist() {
return getRuleContext(MemberdeclaratorlistContext.class,0);
}
public MemberdeclaratorlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_memberdeclaratorlist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterMemberdeclaratorlist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitMemberdeclaratorlist(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitMemberdeclaratorlist(this);
else return visitor.visitChildren(this);
}
}
public final MemberdeclaratorlistContext memberdeclaratorlist() throws RecognitionException {
return memberdeclaratorlist(0);
}
private MemberdeclaratorlistContext memberdeclaratorlist(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
MemberdeclaratorlistContext _localctx = new MemberdeclaratorlistContext(_ctx, _parentState);
MemberdeclaratorlistContext _prevctx = _localctx;
int _startState = 300;
enterRecursionRule(_localctx, 300, RULE_memberdeclaratorlist, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2024);
memberdeclarator();
}
_ctx.stop = _input.LT(-1);
setState(2031);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,249,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new MemberdeclaratorlistContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_memberdeclaratorlist);
setState(2026);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2027);
match(Comma);
setState(2028);
memberdeclarator();
}
}
}
setState(2033);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,249,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class MemberdeclaratorContext extends ParserRuleContext {
public DeclaratorContext declarator() {
return getRuleContext(DeclaratorContext.class,0);
}
public VirtspecifierseqContext virtspecifierseq() {
return getRuleContext(VirtspecifierseqContext.class,0);
}
public PurespecifierContext purespecifier() {
return getRuleContext(PurespecifierContext.class,0);
}
public BraceorequalinitializerContext braceorequalinitializer() {
return getRuleContext(BraceorequalinitializerContext.class,0);
}
public ConstantexpressionContext constantexpression() {
return getRuleContext(ConstantexpressionContext.class,0);
}
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public MemberdeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_memberdeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterMemberdeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitMemberdeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitMemberdeclarator(this);
else return visitor.visitChildren(this);
}
}
public final MemberdeclaratorContext memberdeclarator() throws RecognitionException {
MemberdeclaratorContext _localctx = new MemberdeclaratorContext(_ctx, getState());
enterRule(_localctx, 302, RULE_memberdeclarator);
int _la;
try {
setState(2053);
switch ( getInterpreter().adaptivePredict(_input,255,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2034);
declarator();
setState(2036);
switch ( getInterpreter().adaptivePredict(_input,250,_ctx) ) {
case 1:
{
setState(2035);
virtspecifierseq(0);
}
break;
}
setState(2039);
switch ( getInterpreter().adaptivePredict(_input,251,_ctx) ) {
case 1:
{
setState(2038);
purespecifier();
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2041);
declarator();
setState(2043);
switch ( getInterpreter().adaptivePredict(_input,252,_ctx) ) {
case 1:
{
setState(2042);
braceorequalinitializer();
}
break;
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2046);
_la = _input.LA(1);
if (_la==Identifier) {
{
setState(2045);
match(Identifier);
}
}
setState(2049);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(2048);
attributespecifierseq(0);
}
}
setState(2051);
match(Colon);
setState(2052);
constantexpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class VirtspecifierseqContext extends ParserRuleContext {
public VirtspecifierContext virtspecifier() {
return getRuleContext(VirtspecifierContext.class,0);
}
public VirtspecifierseqContext virtspecifierseq() {
return getRuleContext(VirtspecifierseqContext.class,0);
}
public VirtspecifierseqContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_virtspecifierseq; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterVirtspecifierseq(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitVirtspecifierseq(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitVirtspecifierseq(this);
else return visitor.visitChildren(this);
}
}
public final VirtspecifierseqContext virtspecifierseq() throws RecognitionException {
return virtspecifierseq(0);
}
private VirtspecifierseqContext virtspecifierseq(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
VirtspecifierseqContext _localctx = new VirtspecifierseqContext(_ctx, _parentState);
VirtspecifierseqContext _prevctx = _localctx;
int _startState = 304;
enterRecursionRule(_localctx, 304, RULE_virtspecifierseq, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2056);
virtspecifier();
}
_ctx.stop = _input.LT(-1);
setState(2062);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,256,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new VirtspecifierseqContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_virtspecifierseq);
setState(2058);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2059);
virtspecifier();
}
}
}
setState(2064);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,256,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class VirtspecifierContext extends ParserRuleContext {
public TerminalNode Override() { return getToken(CPP14Parser.Override, 0); }
public TerminalNode Final() { return getToken(CPP14Parser.Final, 0); }
public VirtspecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_virtspecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterVirtspecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitVirtspecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitVirtspecifier(this);
else return visitor.visitChildren(this);
}
}
public final VirtspecifierContext virtspecifier() throws RecognitionException {
VirtspecifierContext _localctx = new VirtspecifierContext(_ctx, getState());
enterRule(_localctx, 306, RULE_virtspecifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2065);
_la = _input.LA(1);
if ( !(_la==Final || _la==Override) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PurespecifierContext extends ParserRuleContext {
public Token val;
public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); }
public TerminalNode Octalliteral() { return getToken(CPP14Parser.Octalliteral, 0); }
public PurespecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_purespecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPurespecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPurespecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitPurespecifier(this);
else return visitor.visitChildren(this);
}
}
public final PurespecifierContext purespecifier() throws RecognitionException {
PurespecifierContext _localctx = new PurespecifierContext(_ctx, getState());
enterRule(_localctx, 308, RULE_purespecifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(2067);
match(Assign);
setState(2068);
((PurespecifierContext)_localctx).val = match(Octalliteral);
if((((PurespecifierContext)_localctx).val!=null?((PurespecifierContext)_localctx).val.getText():null).compareTo("0")!=0) throw new InputMismatchException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BaseclauseContext extends ParserRuleContext {
public BasespecifierlistContext basespecifierlist() {
return getRuleContext(BasespecifierlistContext.class,0);
}
public BaseclauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_baseclause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBaseclause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBaseclause(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitBaseclause(this);
else return visitor.visitChildren(this);
}
}
public final BaseclauseContext baseclause() throws RecognitionException {
BaseclauseContext _localctx = new BaseclauseContext(_ctx, getState());
enterRule(_localctx, 310, RULE_baseclause);
try {
enterOuterAlt(_localctx, 1);
{
setState(2071);
match(Colon);
setState(2072);
basespecifierlist(0);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BasespecifierlistContext extends ParserRuleContext {
public BasespecifierContext basespecifier() {
return getRuleContext(BasespecifierContext.class,0);
}
public BasespecifierlistContext basespecifierlist() {
return getRuleContext(BasespecifierlistContext.class,0);
}
public BasespecifierlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_basespecifierlist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBasespecifierlist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBasespecifierlist(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitBasespecifierlist(this);
else return visitor.visitChildren(this);
}
}
public final BasespecifierlistContext basespecifierlist() throws RecognitionException {
return basespecifierlist(0);
}
private BasespecifierlistContext basespecifierlist(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
BasespecifierlistContext _localctx = new BasespecifierlistContext(_ctx, _parentState);
BasespecifierlistContext _prevctx = _localctx;
int _startState = 312;
enterRecursionRule(_localctx, 312, RULE_basespecifierlist, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2075);
basespecifier();
setState(2077);
switch ( getInterpreter().adaptivePredict(_input,257,_ctx) ) {
case 1:
{
setState(2076);
match(Ellipsis);
}
break;
}
}
_ctx.stop = _input.LT(-1);
setState(2087);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,259,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new BasespecifierlistContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_basespecifierlist);
setState(2079);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2080);
match(Comma);
setState(2081);
basespecifier();
setState(2083);
switch ( getInterpreter().adaptivePredict(_input,258,_ctx) ) {
case 1:
{
setState(2082);
match(Ellipsis);
}
break;
}
}
}
}
setState(2089);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,259,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class BasespecifierContext extends ParserRuleContext {
public BasetypespecifierContext basetypespecifier() {
return getRuleContext(BasetypespecifierContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public TerminalNode Virtual() { return getToken(CPP14Parser.Virtual, 0); }
public AccessspecifierContext accessspecifier() {
return getRuleContext(AccessspecifierContext.class,0);
}
public BasespecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_basespecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBasespecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBasespecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitBasespecifier(this);
else return visitor.visitChildren(this);
}
}
public final BasespecifierContext basespecifier() throws RecognitionException {
BasespecifierContext _localctx = new BasespecifierContext(_ctx, getState());
enterRule(_localctx, 314, RULE_basespecifier);
int _la;
try {
setState(2111);
switch ( getInterpreter().adaptivePredict(_input,265,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2091);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(2090);
attributespecifierseq(0);
}
}
setState(2093);
basetypespecifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2095);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(2094);
attributespecifierseq(0);
}
}
setState(2097);
match(Virtual);
setState(2099);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Private) | (1L << Protected) | (1L << Public))) != 0)) {
{
setState(2098);
accessspecifier();
}
}
setState(2101);
basetypespecifier();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2103);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(2102);
attributespecifierseq(0);
}
}
setState(2105);
accessspecifier();
setState(2107);
_la = _input.LA(1);
if (_la==Virtual) {
{
setState(2106);
match(Virtual);
}
}
setState(2109);
basetypespecifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ClassordecltypeContext extends ParserRuleContext {
public ClassnameContext classname() {
return getRuleContext(ClassnameContext.class,0);
}
public NestednamespecifierContext nestednamespecifier() {
return getRuleContext(NestednamespecifierContext.class,0);
}
public DecltypespecifierContext decltypespecifier() {
return getRuleContext(DecltypespecifierContext.class,0);
}
public ClassordecltypeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_classordecltype; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterClassordecltype(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitClassordecltype(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitClassordecltype(this);
else return visitor.visitChildren(this);
}
}
public final ClassordecltypeContext classordecltype() throws RecognitionException {
ClassordecltypeContext _localctx = new ClassordecltypeContext(_ctx, getState());
enterRule(_localctx, 316, RULE_classordecltype);
try {
setState(2118);
switch ( getInterpreter().adaptivePredict(_input,267,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2114);
switch ( getInterpreter().adaptivePredict(_input,266,_ctx) ) {
case 1:
{
setState(2113);
nestednamespecifier(0);
}
break;
}
setState(2116);
classname();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2117);
decltypespecifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BasetypespecifierContext extends ParserRuleContext {
public ClassordecltypeContext classordecltype() {
return getRuleContext(ClassordecltypeContext.class,0);
}
public BasetypespecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_basetypespecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBasetypespecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBasetypespecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitBasetypespecifier(this);
else return visitor.visitChildren(this);
}
}
public final BasetypespecifierContext basetypespecifier() throws RecognitionException {
BasetypespecifierContext _localctx = new BasetypespecifierContext(_ctx, getState());
enterRule(_localctx, 318, RULE_basetypespecifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(2120);
classordecltype();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AccessspecifierContext extends ParserRuleContext {
public TerminalNode Private() { return getToken(CPP14Parser.Private, 0); }
public TerminalNode Protected() { return getToken(CPP14Parser.Protected, 0); }
public TerminalNode Public() { return getToken(CPP14Parser.Public, 0); }
public AccessspecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_accessspecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterAccessspecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitAccessspecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitAccessspecifier(this);
else return visitor.visitChildren(this);
}
}
public final AccessspecifierContext accessspecifier() throws RecognitionException {
AccessspecifierContext _localctx = new AccessspecifierContext(_ctx, getState());
enterRule(_localctx, 320, RULE_accessspecifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2122);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Private) | (1L << Protected) | (1L << Public))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConversionfunctionidContext extends ParserRuleContext {
public TerminalNode Operator() { return getToken(CPP14Parser.Operator, 0); }
public ConversiontypeidContext conversiontypeid() {
return getRuleContext(ConversiontypeidContext.class,0);
}
public ConversionfunctionidContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conversionfunctionid; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterConversionfunctionid(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitConversionfunctionid(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitConversionfunctionid(this);
else return visitor.visitChildren(this);
}
}
public final ConversionfunctionidContext conversionfunctionid() throws RecognitionException {
ConversionfunctionidContext _localctx = new ConversionfunctionidContext(_ctx, getState());
enterRule(_localctx, 322, RULE_conversionfunctionid);
try {
enterOuterAlt(_localctx, 1);
{
setState(2124);
match(Operator);
setState(2125);
conversiontypeid();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConversiontypeidContext extends ParserRuleContext {
public TypespecifierseqContext typespecifierseq() {
return getRuleContext(TypespecifierseqContext.class,0);
}
public ConversiondeclaratorContext conversiondeclarator() {
return getRuleContext(ConversiondeclaratorContext.class,0);
}
public ConversiontypeidContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conversiontypeid; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterConversiontypeid(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitConversiontypeid(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitConversiontypeid(this);
else return visitor.visitChildren(this);
}
}
public final ConversiontypeidContext conversiontypeid() throws RecognitionException {
ConversiontypeidContext _localctx = new ConversiontypeidContext(_ctx, getState());
enterRule(_localctx, 324, RULE_conversiontypeid);
try {
enterOuterAlt(_localctx, 1);
{
setState(2127);
typespecifierseq();
setState(2129);
switch ( getInterpreter().adaptivePredict(_input,268,_ctx) ) {
case 1:
{
setState(2128);
conversiondeclarator();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConversiondeclaratorContext extends ParserRuleContext {
public PtroperatorContext ptroperator() {
return getRuleContext(PtroperatorContext.class,0);
}
public ConversiondeclaratorContext conversiondeclarator() {
return getRuleContext(ConversiondeclaratorContext.class,0);
}
public ConversiondeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conversiondeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterConversiondeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitConversiondeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitConversiondeclarator(this);
else return visitor.visitChildren(this);
}
}
public final ConversiondeclaratorContext conversiondeclarator() throws RecognitionException {
ConversiondeclaratorContext _localctx = new ConversiondeclaratorContext(_ctx, getState());
enterRule(_localctx, 326, RULE_conversiondeclarator);
try {
enterOuterAlt(_localctx, 1);
{
setState(2131);
ptroperator();
setState(2133);
switch ( getInterpreter().adaptivePredict(_input,269,_ctx) ) {
case 1:
{
setState(2132);
conversiondeclarator();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CtorinitializerContext extends ParserRuleContext {
public MeminitializerlistContext meminitializerlist() {
return getRuleContext(MeminitializerlistContext.class,0);
}
public CtorinitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ctorinitializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterCtorinitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitCtorinitializer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitCtorinitializer(this);
else return visitor.visitChildren(this);
}
}
public final CtorinitializerContext ctorinitializer() throws RecognitionException {
CtorinitializerContext _localctx = new CtorinitializerContext(_ctx, getState());
enterRule(_localctx, 328, RULE_ctorinitializer);
try {
enterOuterAlt(_localctx, 1);
{
setState(2135);
match(Colon);
setState(2136);
meminitializerlist();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MeminitializerlistContext extends ParserRuleContext {
public MeminitializerContext meminitializer() {
return getRuleContext(MeminitializerContext.class,0);
}
public MeminitializerlistContext meminitializerlist() {
return getRuleContext(MeminitializerlistContext.class,0);
}
public MeminitializerlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_meminitializerlist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterMeminitializerlist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitMeminitializerlist(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitMeminitializerlist(this);
else return visitor.visitChildren(this);
}
}
public final MeminitializerlistContext meminitializerlist() throws RecognitionException {
MeminitializerlistContext _localctx = new MeminitializerlistContext(_ctx, getState());
enterRule(_localctx, 330, RULE_meminitializerlist);
int _la;
try {
setState(2149);
switch ( getInterpreter().adaptivePredict(_input,272,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2138);
meminitializer();
setState(2140);
_la = _input.LA(1);
if (_la==Ellipsis) {
{
setState(2139);
match(Ellipsis);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2142);
meminitializer();
setState(2144);
_la = _input.LA(1);
if (_la==Ellipsis) {
{
setState(2143);
match(Ellipsis);
}
}
setState(2146);
match(Comma);
setState(2147);
meminitializerlist();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MeminitializerContext extends ParserRuleContext {
public MeminitializeridContext meminitializerid() {
return getRuleContext(MeminitializeridContext.class,0);
}
public ExpressionlistContext expressionlist() {
return getRuleContext(ExpressionlistContext.class,0);
}
public BracedinitlistContext bracedinitlist() {
return getRuleContext(BracedinitlistContext.class,0);
}
public MeminitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_meminitializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterMeminitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitMeminitializer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitMeminitializer(this);
else return visitor.visitChildren(this);
}
}
public final MeminitializerContext meminitializer() throws RecognitionException {
MeminitializerContext _localctx = new MeminitializerContext(_ctx, getState());
enterRule(_localctx, 332, RULE_meminitializer);
int _la;
try {
setState(2161);
switch ( getInterpreter().adaptivePredict(_input,274,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2151);
meminitializerid();
setState(2152);
match(LeftParen);
setState(2154);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << False) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static_cast) | (1L << This))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Throw - 64)) | (1L << (True - 64)) | (1L << (Typeid - 64)) | (1L << (Typename - 64)) | (1L << (Unsigned - 64)) | (1L << (Void - 64)) | (1L << (Wchar - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (LeftBrace - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Doublecolon - 64)) | (1L << (Identifier - 64)) | (1L << (Integerliteral - 64)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(2153);
expressionlist();
}
}
setState(2156);
match(RightParen);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2158);
meminitializerid();
setState(2159);
bracedinitlist();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MeminitializeridContext extends ParserRuleContext {
public ClassordecltypeContext classordecltype() {
return getRuleContext(ClassordecltypeContext.class,0);
}
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public MeminitializeridContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_meminitializerid; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterMeminitializerid(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitMeminitializerid(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitMeminitializerid(this);
else return visitor.visitChildren(this);
}
}
public final MeminitializeridContext meminitializerid() throws RecognitionException {
MeminitializeridContext _localctx = new MeminitializeridContext(_ctx, getState());
enterRule(_localctx, 334, RULE_meminitializerid);
try {
setState(2165);
switch ( getInterpreter().adaptivePredict(_input,275,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2163);
classordecltype();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2164);
match(Identifier);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OperatorfunctionidContext extends ParserRuleContext {
public TerminalNode Operator() { return getToken(CPP14Parser.Operator, 0); }
public OperatorContext operator() {
return getRuleContext(OperatorContext.class,0);
}
public OperatorfunctionidContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_operatorfunctionid; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterOperatorfunctionid(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitOperatorfunctionid(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitOperatorfunctionid(this);
else return visitor.visitChildren(this);
}
}
public final OperatorfunctionidContext operatorfunctionid() throws RecognitionException {
OperatorfunctionidContext _localctx = new OperatorfunctionidContext(_ctx, getState());
enterRule(_localctx, 336, RULE_operatorfunctionid);
try {
enterOuterAlt(_localctx, 1);
{
setState(2167);
match(Operator);
setState(2168);
operator();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LiteraloperatoridContext extends ParserRuleContext {
public TerminalNode Operator() { return getToken(CPP14Parser.Operator, 0); }
public TerminalNode Stringliteral() { return getToken(CPP14Parser.Stringliteral, 0); }
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public TerminalNode Userdefinedstringliteral() { return getToken(CPP14Parser.Userdefinedstringliteral, 0); }
public LiteraloperatoridContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literaloperatorid; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLiteraloperatorid(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLiteraloperatorid(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitLiteraloperatorid(this);
else return visitor.visitChildren(this);
}
}
public final LiteraloperatoridContext literaloperatorid() throws RecognitionException {
LiteraloperatoridContext _localctx = new LiteraloperatoridContext(_ctx, getState());
enterRule(_localctx, 338, RULE_literaloperatorid);
try {
setState(2175);
switch ( getInterpreter().adaptivePredict(_input,276,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2170);
match(Operator);
setState(2171);
match(Stringliteral);
setState(2172);
match(Identifier);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2173);
match(Operator);
setState(2174);
match(Userdefinedstringliteral);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TemplatedeclarationContext extends ParserRuleContext {
public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
public TemplateparameterlistContext templateparameterlist() {
return getRuleContext(TemplateparameterlistContext.class,0);
}
public DeclarationContext declaration() {
return getRuleContext(DeclarationContext.class,0);
}
public TemplatedeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_templatedeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTemplatedeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTemplatedeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTemplatedeclaration(this);
else return visitor.visitChildren(this);
}
}
public final TemplatedeclarationContext templatedeclaration() throws RecognitionException {
TemplatedeclarationContext _localctx = new TemplatedeclarationContext(_ctx, getState());
enterRule(_localctx, 340, RULE_templatedeclaration);
try {
enterOuterAlt(_localctx, 1);
{
setState(2177);
match(Template);
setState(2178);
match(Less);
setState(2179);
templateparameterlist(0);
setState(2180);
match(Greater);
setState(2181);
declaration();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TemplateparameterlistContext extends ParserRuleContext {
public TemplateparameterContext templateparameter() {
return getRuleContext(TemplateparameterContext.class,0);
}
public TemplateparameterlistContext templateparameterlist() {
return getRuleContext(TemplateparameterlistContext.class,0);
}
public TemplateparameterlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_templateparameterlist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTemplateparameterlist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTemplateparameterlist(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTemplateparameterlist(this);
else return visitor.visitChildren(this);
}
}
public final TemplateparameterlistContext templateparameterlist() throws RecognitionException {
return templateparameterlist(0);
}
private TemplateparameterlistContext templateparameterlist(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
TemplateparameterlistContext _localctx = new TemplateparameterlistContext(_ctx, _parentState);
TemplateparameterlistContext _prevctx = _localctx;
int _startState = 342;
enterRecursionRule(_localctx, 342, RULE_templateparameterlist, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2184);
templateparameter();
}
_ctx.stop = _input.LT(-1);
setState(2191);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,277,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new TemplateparameterlistContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_templateparameterlist);
setState(2186);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2187);
match(Comma);
setState(2188);
templateparameter();
}
}
}
setState(2193);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,277,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class TemplateparameterContext extends ParserRuleContext {
public TypeparameterContext typeparameter() {
return getRuleContext(TypeparameterContext.class,0);
}
public ParameterdeclarationContext parameterdeclaration() {
return getRuleContext(ParameterdeclarationContext.class,0);
}
public TemplateparameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_templateparameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTemplateparameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTemplateparameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTemplateparameter(this);
else return visitor.visitChildren(this);
}
}
public final TemplateparameterContext templateparameter() throws RecognitionException {
TemplateparameterContext _localctx = new TemplateparameterContext(_ctx, getState());
enterRule(_localctx, 344, RULE_templateparameter);
try {
setState(2196);
switch ( getInterpreter().adaptivePredict(_input,278,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2194);
typeparameter();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2195);
parameterdeclaration();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeparameterContext extends ParserRuleContext {
public TerminalNode Class() { return getToken(CPP14Parser.Class, 0); }
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public TypeidContext typeid() {
return getRuleContext(TypeidContext.class,0);
}
public TerminalNode Typename() { return getToken(CPP14Parser.Typename, 0); }
public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
public TemplateparameterlistContext templateparameterlist() {
return getRuleContext(TemplateparameterlistContext.class,0);
}
public IdexpressionContext idexpression() {
return getRuleContext(IdexpressionContext.class,0);
}
public TypeparameterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeparameter; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypeparameter(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypeparameter(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTypeparameter(this);
else return visitor.visitChildren(this);
}
}
public final TypeparameterContext typeparameter() throws RecognitionException {
TypeparameterContext _localctx = new TypeparameterContext(_ctx, getState());
enterRule(_localctx, 346, RULE_typeparameter);
int _la;
try {
setState(2246);
switch ( getInterpreter().adaptivePredict(_input,288,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2198);
match(Class);
setState(2200);
switch ( getInterpreter().adaptivePredict(_input,279,_ctx) ) {
case 1:
{
setState(2199);
match(Ellipsis);
}
break;
}
setState(2203);
switch ( getInterpreter().adaptivePredict(_input,280,_ctx) ) {
case 1:
{
setState(2202);
match(Identifier);
}
break;
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2205);
match(Class);
setState(2207);
_la = _input.LA(1);
if (_la==Identifier) {
{
setState(2206);
match(Identifier);
}
}
setState(2209);
match(Assign);
setState(2210);
typeid();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2211);
match(Typename);
setState(2213);
switch ( getInterpreter().adaptivePredict(_input,282,_ctx) ) {
case 1:
{
setState(2212);
match(Ellipsis);
}
break;
}
setState(2216);
switch ( getInterpreter().adaptivePredict(_input,283,_ctx) ) {
case 1:
{
setState(2215);
match(Identifier);
}
break;
}
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2218);
match(Typename);
setState(2220);
_la = _input.LA(1);
if (_la==Identifier) {
{
setState(2219);
match(Identifier);
}
}
setState(2222);
match(Assign);
setState(2223);
typeid();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2224);
match(Template);
setState(2225);
match(Less);
setState(2226);
templateparameterlist(0);
setState(2227);
match(Greater);
setState(2228);
match(Class);
setState(2230);
switch ( getInterpreter().adaptivePredict(_input,285,_ctx) ) {
case 1:
{
setState(2229);
match(Ellipsis);
}
break;
}
setState(2233);
switch ( getInterpreter().adaptivePredict(_input,286,_ctx) ) {
case 1:
{
setState(2232);
match(Identifier);
}
break;
}
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2235);
match(Template);
setState(2236);
match(Less);
setState(2237);
templateparameterlist(0);
setState(2238);
match(Greater);
setState(2239);
match(Class);
setState(2241);
_la = _input.LA(1);
if (_la==Identifier) {
{
setState(2240);
match(Identifier);
}
}
setState(2243);
match(Assign);
setState(2244);
idexpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SimpletemplateidContext extends ParserRuleContext {
public TemplatenameContext templatename() {
return getRuleContext(TemplatenameContext.class,0);
}
public TemplateargumentlistContext templateargumentlist() {
return getRuleContext(TemplateargumentlistContext.class,0);
}
public SimpletemplateidContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simpletemplateid; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterSimpletemplateid(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitSimpletemplateid(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitSimpletemplateid(this);
else return visitor.visitChildren(this);
}
}
public final SimpletemplateidContext simpletemplateid() throws RecognitionException {
SimpletemplateidContext _localctx = new SimpletemplateidContext(_ctx, getState());
enterRule(_localctx, 348, RULE_simpletemplateid);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2248);
templatename();
setState(2249);
match(Less);
setState(2251);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Enum) | (1L << False) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static_cast) | (1L << Struct) | (1L << This))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (True - 65)) | (1L << (Typeid - 65)) | (1L << (Typename - 65)) | (1L << (Union - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Volatile - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)) | (1L << (Identifier - 65)) | (1L << (Integerliteral - 65)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(2250);
templateargumentlist(0);
}
}
setState(2253);
match(Greater);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TemplateidContext extends ParserRuleContext {
public SimpletemplateidContext simpletemplateid() {
return getRuleContext(SimpletemplateidContext.class,0);
}
public OperatorfunctionidContext operatorfunctionid() {
return getRuleContext(OperatorfunctionidContext.class,0);
}
public TemplateargumentlistContext templateargumentlist() {
return getRuleContext(TemplateargumentlistContext.class,0);
}
public LiteraloperatoridContext literaloperatorid() {
return getRuleContext(LiteraloperatoridContext.class,0);
}
public TemplateidContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_templateid; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTemplateid(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTemplateid(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTemplateid(this);
else return visitor.visitChildren(this);
}
}
public final TemplateidContext templateid() throws RecognitionException {
TemplateidContext _localctx = new TemplateidContext(_ctx, getState());
enterRule(_localctx, 350, RULE_templateid);
int _la;
try {
setState(2270);
switch ( getInterpreter().adaptivePredict(_input,292,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2255);
simpletemplateid();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2256);
operatorfunctionid();
setState(2257);
match(Less);
setState(2259);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Enum) | (1L << False) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static_cast) | (1L << Struct) | (1L << This))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (True - 65)) | (1L << (Typeid - 65)) | (1L << (Typename - 65)) | (1L << (Union - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Volatile - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)) | (1L << (Identifier - 65)) | (1L << (Integerliteral - 65)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(2258);
templateargumentlist(0);
}
}
setState(2261);
match(Greater);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2263);
literaloperatorid();
setState(2264);
match(Less);
setState(2266);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Enum) | (1L << False) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static_cast) | (1L << Struct) | (1L << This))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (True - 65)) | (1L << (Typeid - 65)) | (1L << (Typename - 65)) | (1L << (Union - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Volatile - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)) | (1L << (Identifier - 65)) | (1L << (Integerliteral - 65)))) != 0) || ((((_la - 132)) & ~0x3f) == 0 && ((1L << (_la - 132)) & ((1L << (Characterliteral - 132)) | (1L << (Floatingliteral - 132)) | (1L << (Stringliteral - 132)) | (1L << (Userdefinedintegerliteral - 132)) | (1L << (Userdefinedfloatingliteral - 132)) | (1L << (Userdefinedstringliteral - 132)) | (1L << (Userdefinedcharacterliteral - 132)))) != 0)) {
{
setState(2265);
templateargumentlist(0);
}
}
setState(2268);
match(Greater);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TemplatenameContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public TemplatenameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_templatename; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTemplatename(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTemplatename(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTemplatename(this);
else return visitor.visitChildren(this);
}
}
public final TemplatenameContext templatename() throws RecognitionException {
TemplatenameContext _localctx = new TemplatenameContext(_ctx, getState());
enterRule(_localctx, 352, RULE_templatename);
try {
enterOuterAlt(_localctx, 1);
{
setState(2272);
match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TemplateargumentlistContext extends ParserRuleContext {
public TemplateargumentContext templateargument() {
return getRuleContext(TemplateargumentContext.class,0);
}
public TemplateargumentlistContext templateargumentlist() {
return getRuleContext(TemplateargumentlistContext.class,0);
}
public TemplateargumentlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_templateargumentlist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTemplateargumentlist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTemplateargumentlist(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTemplateargumentlist(this);
else return visitor.visitChildren(this);
}
}
public final TemplateargumentlistContext templateargumentlist() throws RecognitionException {
return templateargumentlist(0);
}
private TemplateargumentlistContext templateargumentlist(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
TemplateargumentlistContext _localctx = new TemplateargumentlistContext(_ctx, _parentState);
TemplateargumentlistContext _prevctx = _localctx;
int _startState = 354;
enterRecursionRule(_localctx, 354, RULE_templateargumentlist, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2275);
templateargument();
setState(2277);
switch ( getInterpreter().adaptivePredict(_input,293,_ctx) ) {
case 1:
{
setState(2276);
match(Ellipsis);
}
break;
}
}
_ctx.stop = _input.LT(-1);
setState(2287);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,295,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new TemplateargumentlistContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_templateargumentlist);
setState(2279);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2280);
match(Comma);
setState(2281);
templateargument();
setState(2283);
switch ( getInterpreter().adaptivePredict(_input,294,_ctx) ) {
case 1:
{
setState(2282);
match(Ellipsis);
}
break;
}
}
}
}
setState(2289);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,295,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class TemplateargumentContext extends ParserRuleContext {
public TypeidContext typeid() {
return getRuleContext(TypeidContext.class,0);
}
public ConstantexpressionContext constantexpression() {
return getRuleContext(ConstantexpressionContext.class,0);
}
public IdexpressionContext idexpression() {
return getRuleContext(IdexpressionContext.class,0);
}
public TemplateargumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_templateargument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTemplateargument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTemplateargument(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTemplateargument(this);
else return visitor.visitChildren(this);
}
}
public final TemplateargumentContext templateargument() throws RecognitionException {
TemplateargumentContext _localctx = new TemplateargumentContext(_ctx, getState());
enterRule(_localctx, 356, RULE_templateargument);
try {
setState(2293);
switch ( getInterpreter().adaptivePredict(_input,296,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2290);
typeid();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2291);
constantexpression();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2292);
idexpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypenamespecifierContext extends ParserRuleContext {
public TerminalNode Typename() { return getToken(CPP14Parser.Typename, 0); }
public NestednamespecifierContext nestednamespecifier() {
return getRuleContext(NestednamespecifierContext.class,0);
}
public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); }
public SimpletemplateidContext simpletemplateid() {
return getRuleContext(SimpletemplateidContext.class,0);
}
public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
public TypenamespecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typenamespecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypenamespecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypenamespecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTypenamespecifier(this);
else return visitor.visitChildren(this);
}
}
public final TypenamespecifierContext typenamespecifier() throws RecognitionException {
TypenamespecifierContext _localctx = new TypenamespecifierContext(_ctx, getState());
enterRule(_localctx, 358, RULE_typenamespecifier);
int _la;
try {
setState(2306);
switch ( getInterpreter().adaptivePredict(_input,298,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2295);
match(Typename);
setState(2296);
nestednamespecifier(0);
setState(2297);
match(Identifier);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2299);
match(Typename);
setState(2300);
nestednamespecifier(0);
setState(2302);
_la = _input.LA(1);
if (_la==Template) {
{
setState(2301);
match(Template);
}
}
setState(2304);
simpletemplateid();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExplicitinstantiationContext extends ParserRuleContext {
public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
public DeclarationContext declaration() {
return getRuleContext(DeclarationContext.class,0);
}
public TerminalNode Extern() { return getToken(CPP14Parser.Extern, 0); }
public ExplicitinstantiationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_explicitinstantiation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExplicitinstantiation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExplicitinstantiation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitExplicitinstantiation(this);
else return visitor.visitChildren(this);
}
}
public final ExplicitinstantiationContext explicitinstantiation() throws RecognitionException {
ExplicitinstantiationContext _localctx = new ExplicitinstantiationContext(_ctx, getState());
enterRule(_localctx, 360, RULE_explicitinstantiation);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2309);
_la = _input.LA(1);
if (_la==Extern) {
{
setState(2308);
match(Extern);
}
}
setState(2311);
match(Template);
setState(2312);
declaration();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExplicitspecializationContext extends ParserRuleContext {
public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); }
public DeclarationContext declaration() {
return getRuleContext(DeclarationContext.class,0);
}
public ExplicitspecializationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_explicitspecialization; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExplicitspecialization(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExplicitspecialization(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitExplicitspecialization(this);
else return visitor.visitChildren(this);
}
}
public final ExplicitspecializationContext explicitspecialization() throws RecognitionException {
ExplicitspecializationContext _localctx = new ExplicitspecializationContext(_ctx, getState());
enterRule(_localctx, 362, RULE_explicitspecialization);
try {
enterOuterAlt(_localctx, 1);
{
setState(2314);
match(Template);
setState(2315);
match(Less);
setState(2316);
match(Greater);
setState(2317);
declaration();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TryblockContext extends ParserRuleContext {
public TerminalNode Try() { return getToken(CPP14Parser.Try, 0); }
public CompoundstatementContext compoundstatement() {
return getRuleContext(CompoundstatementContext.class,0);
}
public HandlerseqContext handlerseq() {
return getRuleContext(HandlerseqContext.class,0);
}
public TryblockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_tryblock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTryblock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTryblock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTryblock(this);
else return visitor.visitChildren(this);
}
}
public final TryblockContext tryblock() throws RecognitionException {
TryblockContext _localctx = new TryblockContext(_ctx, getState());
enterRule(_localctx, 364, RULE_tryblock);
try {
enterOuterAlt(_localctx, 1);
{
setState(2319);
match(Try);
setState(2320);
compoundstatement();
setState(2321);
handlerseq();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctiontryblockContext extends ParserRuleContext {
public TerminalNode Try() { return getToken(CPP14Parser.Try, 0); }
public CompoundstatementContext compoundstatement() {
return getRuleContext(CompoundstatementContext.class,0);
}
public HandlerseqContext handlerseq() {
return getRuleContext(HandlerseqContext.class,0);
}
public CtorinitializerContext ctorinitializer() {
return getRuleContext(CtorinitializerContext.class,0);
}
public FunctiontryblockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_functiontryblock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterFunctiontryblock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitFunctiontryblock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitFunctiontryblock(this);
else return visitor.visitChildren(this);
}
}
public final FunctiontryblockContext functiontryblock() throws RecognitionException {
FunctiontryblockContext _localctx = new FunctiontryblockContext(_ctx, getState());
enterRule(_localctx, 366, RULE_functiontryblock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2323);
match(Try);
setState(2325);
_la = _input.LA(1);
if (_la==Colon) {
{
setState(2324);
ctorinitializer();
}
}
setState(2327);
compoundstatement();
setState(2328);
handlerseq();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HandlerseqContext extends ParserRuleContext {
public HandlerContext handler() {
return getRuleContext(HandlerContext.class,0);
}
public HandlerseqContext handlerseq() {
return getRuleContext(HandlerseqContext.class,0);
}
public HandlerseqContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_handlerseq; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterHandlerseq(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitHandlerseq(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitHandlerseq(this);
else return visitor.visitChildren(this);
}
}
public final HandlerseqContext handlerseq() throws RecognitionException {
HandlerseqContext _localctx = new HandlerseqContext(_ctx, getState());
enterRule(_localctx, 368, RULE_handlerseq);
try {
enterOuterAlt(_localctx, 1);
{
setState(2330);
handler();
setState(2332);
switch ( getInterpreter().adaptivePredict(_input,301,_ctx) ) {
case 1:
{
setState(2331);
handlerseq();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class HandlerContext extends ParserRuleContext {
public TerminalNode Catch() { return getToken(CPP14Parser.Catch, 0); }
public ExceptiondeclarationContext exceptiondeclaration() {
return getRuleContext(ExceptiondeclarationContext.class,0);
}
public CompoundstatementContext compoundstatement() {
return getRuleContext(CompoundstatementContext.class,0);
}
public HandlerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_handler; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterHandler(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitHandler(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitHandler(this);
else return visitor.visitChildren(this);
}
}
public final HandlerContext handler() throws RecognitionException {
HandlerContext _localctx = new HandlerContext(_ctx, getState());
enterRule(_localctx, 370, RULE_handler);
try {
enterOuterAlt(_localctx, 1);
{
setState(2334);
match(Catch);
setState(2335);
match(LeftParen);
setState(2336);
exceptiondeclaration();
setState(2337);
match(RightParen);
setState(2338);
compoundstatement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExceptiondeclarationContext extends ParserRuleContext {
public TypespecifierseqContext typespecifierseq() {
return getRuleContext(TypespecifierseqContext.class,0);
}
public DeclaratorContext declarator() {
return getRuleContext(DeclaratorContext.class,0);
}
public AttributespecifierseqContext attributespecifierseq() {
return getRuleContext(AttributespecifierseqContext.class,0);
}
public AbstractdeclaratorContext abstractdeclarator() {
return getRuleContext(AbstractdeclaratorContext.class,0);
}
public ExceptiondeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exceptiondeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExceptiondeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExceptiondeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitExceptiondeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ExceptiondeclarationContext exceptiondeclaration() throws RecognitionException {
ExceptiondeclarationContext _localctx = new ExceptiondeclarationContext(_ctx, getState());
enterRule(_localctx, 372, RULE_exceptiondeclaration);
int _la;
try {
setState(2354);
switch ( getInterpreter().adaptivePredict(_input,305,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2341);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(2340);
attributespecifierseq(0);
}
}
setState(2343);
typespecifierseq();
setState(2344);
declarator();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2347);
_la = _input.LA(1);
if (_la==Alignas || _la==LeftBracket) {
{
setState(2346);
attributespecifierseq(0);
}
}
setState(2349);
typespecifierseq();
setState(2351);
_la = _input.LA(1);
if (_la==Decltype || ((((_la - 78)) & ~0x3f) == 0 && ((1L << (_la - 78)) & ((1L << (LeftParen - 78)) | (1L << (LeftBracket - 78)) | (1L << (Star - 78)) | (1L << (And - 78)) | (1L << (AndAnd - 78)) | (1L << (Doublecolon - 78)) | (1L << (Ellipsis - 78)) | (1L << (Identifier - 78)))) != 0)) {
{
setState(2350);
abstractdeclarator();
}
}
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2353);
match(Ellipsis);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ThrowexpressionContext extends ParserRuleContext {
public TerminalNode Throw() { return getToken(CPP14Parser.Throw, 0); }
public AssignmentexpressionContext assignmentexpression() {
return getRuleContext(AssignmentexpressionContext.class,0);
}
public ThrowexpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_throwexpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterThrowexpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitThrowexpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitThrowexpression(this);
else return visitor.visitChildren(this);
}
}
public final ThrowexpressionContext throwexpression() throws RecognitionException {
ThrowexpressionContext _localctx = new ThrowexpressionContext(_ctx, getState());
enterRule(_localctx, 374, RULE_throwexpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(2356);
match(Throw);
setState(2358);
switch ( getInterpreter().adaptivePredict(_input,306,_ctx) ) {
case 1:
{
setState(2357);
assignmentexpression();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExceptionspecificationContext extends ParserRuleContext {
public DynamicexceptionspecificationContext dynamicexceptionspecification() {
return getRuleContext(DynamicexceptionspecificationContext.class,0);
}
public NoexceptspecificationContext noexceptspecification() {
return getRuleContext(NoexceptspecificationContext.class,0);
}
public ExceptionspecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exceptionspecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterExceptionspecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitExceptionspecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitExceptionspecification(this);
else return visitor.visitChildren(this);
}
}
public final ExceptionspecificationContext exceptionspecification() throws RecognitionException {
ExceptionspecificationContext _localctx = new ExceptionspecificationContext(_ctx, getState());
enterRule(_localctx, 376, RULE_exceptionspecification);
try {
setState(2362);
switch (_input.LA(1)) {
case Throw:
enterOuterAlt(_localctx, 1);
{
setState(2360);
dynamicexceptionspecification();
}
break;
case Noexcept:
enterOuterAlt(_localctx, 2);
{
setState(2361);
noexceptspecification();
}
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 DynamicexceptionspecificationContext extends ParserRuleContext {
public TerminalNode Throw() { return getToken(CPP14Parser.Throw, 0); }
public TypeidlistContext typeidlist() {
return getRuleContext(TypeidlistContext.class,0);
}
public DynamicexceptionspecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_dynamicexceptionspecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterDynamicexceptionspecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitDynamicexceptionspecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitDynamicexceptionspecification(this);
else return visitor.visitChildren(this);
}
}
public final DynamicexceptionspecificationContext dynamicexceptionspecification() throws RecognitionException {
DynamicexceptionspecificationContext _localctx = new DynamicexceptionspecificationContext(_ctx, getState());
enterRule(_localctx, 378, RULE_dynamicexceptionspecification);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2364);
match(Throw);
setState(2365);
match(LeftParen);
setState(2367);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Decltype) | (1L << Double) | (1L << Enum) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << Short) | (1L << Signed) | (1L << Struct))) != 0) || ((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (Typename - 69)) | (1L << (Union - 69)) | (1L << (Unsigned - 69)) | (1L << (Void - 69)) | (1L << (Volatile - 69)) | (1L << (Wchar - 69)) | (1L << (Doublecolon - 69)) | (1L << (Identifier - 69)))) != 0)) {
{
setState(2366);
typeidlist(0);
}
}
setState(2369);
match(RightParen);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeidlistContext extends ParserRuleContext {
public TypeidContext typeid() {
return getRuleContext(TypeidContext.class,0);
}
public TypeidlistContext typeidlist() {
return getRuleContext(TypeidlistContext.class,0);
}
public TypeidlistContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeidlist; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterTypeidlist(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitTypeidlist(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitTypeidlist(this);
else return visitor.visitChildren(this);
}
}
public final TypeidlistContext typeidlist() throws RecognitionException {
return typeidlist(0);
}
private TypeidlistContext typeidlist(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
TypeidlistContext _localctx = new TypeidlistContext(_ctx, _parentState);
TypeidlistContext _prevctx = _localctx;
int _startState = 380;
enterRecursionRule(_localctx, 380, RULE_typeidlist, _p);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
setState(2372);
typeid();
setState(2374);
switch ( getInterpreter().adaptivePredict(_input,309,_ctx) ) {
case 1:
{
setState(2373);
match(Ellipsis);
}
break;
}
}
_ctx.stop = _input.LT(-1);
setState(2384);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,311,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
{
_localctx = new TypeidlistContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_typeidlist);
setState(2376);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(2377);
match(Comma);
setState(2378);
typeid();
setState(2380);
switch ( getInterpreter().adaptivePredict(_input,310,_ctx) ) {
case 1:
{
setState(2379);
match(Ellipsis);
}
break;
}
}
}
}
setState(2386);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,311,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class NoexceptspecificationContext extends ParserRuleContext {
public TerminalNode Noexcept() { return getToken(CPP14Parser.Noexcept, 0); }
public ConstantexpressionContext constantexpression() {
return getRuleContext(ConstantexpressionContext.class,0);
}
public NoexceptspecificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_noexceptspecification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterNoexceptspecification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitNoexceptspecification(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitNoexceptspecification(this);
else return visitor.visitChildren(this);
}
}
public final NoexceptspecificationContext noexceptspecification() throws RecognitionException {
NoexceptspecificationContext _localctx = new NoexceptspecificationContext(_ctx, getState());
enterRule(_localctx, 382, RULE_noexceptspecification);
try {
setState(2393);
switch ( getInterpreter().adaptivePredict(_input,312,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2387);
match(Noexcept);
setState(2388);
match(LeftParen);
setState(2389);
constantexpression();
setState(2390);
match(RightParen);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2392);
match(Noexcept);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RightShiftContext extends ParserRuleContext {
public List Greater() { return getTokens(CPP14Parser.Greater); }
public TerminalNode Greater(int i) {
return getToken(CPP14Parser.Greater, i);
}
public RightShiftContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rightShift; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterRightShift(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitRightShift(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitRightShift(this);
else return visitor.visitChildren(this);
}
}
public final RightShiftContext rightShift() throws RecognitionException {
RightShiftContext _localctx = new RightShiftContext(_ctx, getState());
enterRule(_localctx, 384, RULE_rightShift);
try {
enterOuterAlt(_localctx, 1);
{
setState(2395);
match(Greater);
setState(2396);
match(Greater);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RightShiftAssignContext extends ParserRuleContext {
public List Greater() { return getTokens(CPP14Parser.Greater); }
public TerminalNode Greater(int i) {
return getToken(CPP14Parser.Greater, i);
}
public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); }
public RightShiftAssignContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_rightShiftAssign; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterRightShiftAssign(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitRightShiftAssign(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitRightShiftAssign(this);
else return visitor.visitChildren(this);
}
}
public final RightShiftAssignContext rightShiftAssign() throws RecognitionException {
RightShiftAssignContext _localctx = new RightShiftAssignContext(_ctx, getState());
enterRule(_localctx, 386, RULE_rightShiftAssign);
try {
enterOuterAlt(_localctx, 1);
{
setState(2398);
match(Greater);
setState(2399);
match(Greater);
setState(2400);
match(Assign);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OperatorContext extends ParserRuleContext {
public TerminalNode New() { return getToken(CPP14Parser.New, 0); }
public TerminalNode Delete() { return getToken(CPP14Parser.Delete, 0); }
public RightShiftContext rightShift() {
return getRuleContext(RightShiftContext.class,0);
}
public RightShiftAssignContext rightShiftAssign() {
return getRuleContext(RightShiftAssignContext.class,0);
}
public OperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitOperator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitOperator(this);
else return visitor.visitChildren(this);
}
}
public final OperatorContext operator() throws RecognitionException {
OperatorContext _localctx = new OperatorContext(_ctx, getState());
enterRule(_localctx, 388, RULE_operator);
try {
setState(2450);
switch ( getInterpreter().adaptivePredict(_input,313,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(2402);
match(New);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(2403);
match(Delete);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(2404);
match(New);
setState(2405);
match(LeftBracket);
setState(2406);
match(RightBracket);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(2407);
match(Delete);
setState(2408);
match(LeftBracket);
setState(2409);
match(RightBracket);
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(2410);
match(Plus);
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(2411);
match(Minus);
}
break;
case 7:
enterOuterAlt(_localctx, 7);
{
setState(2412);
match(Star);
}
break;
case 8:
enterOuterAlt(_localctx, 8);
{
setState(2413);
match(Div);
}
break;
case 9:
enterOuterAlt(_localctx, 9);
{
setState(2414);
match(Mod);
}
break;
case 10:
enterOuterAlt(_localctx, 10);
{
setState(2415);
match(Caret);
}
break;
case 11:
enterOuterAlt(_localctx, 11);
{
setState(2416);
match(And);
}
break;
case 12:
enterOuterAlt(_localctx, 12);
{
setState(2417);
match(Or);
}
break;
case 13:
enterOuterAlt(_localctx, 13);
{
setState(2418);
match(Tilde);
}
break;
case 14:
enterOuterAlt(_localctx, 14);
{
setState(2419);
match(Not);
}
break;
case 15:
enterOuterAlt(_localctx, 15);
{
setState(2420);
match(Assign);
}
break;
case 16:
enterOuterAlt(_localctx, 16);
{
setState(2421);
match(Less);
}
break;
case 17:
enterOuterAlt(_localctx, 17);
{
setState(2422);
match(Greater);
}
break;
case 18:
enterOuterAlt(_localctx, 18);
{
setState(2423);
match(PlusAssign);
}
break;
case 19:
enterOuterAlt(_localctx, 19);
{
setState(2424);
match(MinusAssign);
}
break;
case 20:
enterOuterAlt(_localctx, 20);
{
setState(2425);
match(StarAssign);
}
break;
case 21:
enterOuterAlt(_localctx, 21);
{
setState(2426);
match(DivAssign);
}
break;
case 22:
enterOuterAlt(_localctx, 22);
{
setState(2427);
match(ModAssign);
}
break;
case 23:
enterOuterAlt(_localctx, 23);
{
setState(2428);
match(XorAssign);
}
break;
case 24:
enterOuterAlt(_localctx, 24);
{
setState(2429);
match(AndAssign);
}
break;
case 25:
enterOuterAlt(_localctx, 25);
{
setState(2430);
match(OrAssign);
}
break;
case 26:
enterOuterAlt(_localctx, 26);
{
setState(2431);
match(LeftShift);
}
break;
case 27:
enterOuterAlt(_localctx, 27);
{
setState(2432);
rightShift();
}
break;
case 28:
enterOuterAlt(_localctx, 28);
{
setState(2433);
rightShiftAssign();
}
break;
case 29:
enterOuterAlt(_localctx, 29);
{
setState(2434);
match(LeftShiftAssign);
}
break;
case 30:
enterOuterAlt(_localctx, 30);
{
setState(2435);
match(Equal);
}
break;
case 31:
enterOuterAlt(_localctx, 31);
{
setState(2436);
match(NotEqual);
}
break;
case 32:
enterOuterAlt(_localctx, 32);
{
setState(2437);
match(LessEqual);
}
break;
case 33:
enterOuterAlt(_localctx, 33);
{
setState(2438);
match(GreaterEqual);
}
break;
case 34:
enterOuterAlt(_localctx, 34);
{
setState(2439);
match(AndAnd);
}
break;
case 35:
enterOuterAlt(_localctx, 35);
{
setState(2440);
match(OrOr);
}
break;
case 36:
enterOuterAlt(_localctx, 36);
{
setState(2441);
match(PlusPlus);
}
break;
case 37:
enterOuterAlt(_localctx, 37);
{
setState(2442);
match(MinusMinus);
}
break;
case 38:
enterOuterAlt(_localctx, 38);
{
setState(2443);
match(Comma);
}
break;
case 39:
enterOuterAlt(_localctx, 39);
{
setState(2444);
match(ArrowStar);
}
break;
case 40:
enterOuterAlt(_localctx, 40);
{
setState(2445);
match(Arrow);
}
break;
case 41:
enterOuterAlt(_localctx, 41);
{
setState(2446);
match(LeftParen);
setState(2447);
match(RightParen);
}
break;
case 42:
enterOuterAlt(_localctx, 42);
{
setState(2448);
match(LeftBracket);
setState(2449);
match(RightBracket);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LiteralContext extends ParserRuleContext {
public TerminalNode Integerliteral() { return getToken(CPP14Parser.Integerliteral, 0); }
public TerminalNode Characterliteral() { return getToken(CPP14Parser.Characterliteral, 0); }
public TerminalNode Floatingliteral() { return getToken(CPP14Parser.Floatingliteral, 0); }
public TerminalNode Stringliteral() { return getToken(CPP14Parser.Stringliteral, 0); }
public BooleanliteralContext booleanliteral() {
return getRuleContext(BooleanliteralContext.class,0);
}
public PointerliteralContext pointerliteral() {
return getRuleContext(PointerliteralContext.class,0);
}
public UserdefinedliteralContext userdefinedliteral() {
return getRuleContext(UserdefinedliteralContext.class,0);
}
public LiteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_literal; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterLiteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitLiteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitLiteral(this);
else return visitor.visitChildren(this);
}
}
public final LiteralContext literal() throws RecognitionException {
LiteralContext _localctx = new LiteralContext(_ctx, getState());
enterRule(_localctx, 390, RULE_literal);
try {
setState(2459);
switch (_input.LA(1)) {
case Integerliteral:
enterOuterAlt(_localctx, 1);
{
setState(2452);
match(Integerliteral);
}
break;
case Characterliteral:
enterOuterAlt(_localctx, 2);
{
setState(2453);
match(Characterliteral);
}
break;
case Floatingliteral:
enterOuterAlt(_localctx, 3);
{
setState(2454);
match(Floatingliteral);
}
break;
case Stringliteral:
enterOuterAlt(_localctx, 4);
{
setState(2455);
match(Stringliteral);
}
break;
case False:
case True:
enterOuterAlt(_localctx, 5);
{
setState(2456);
booleanliteral();
}
break;
case Nullptr:
enterOuterAlt(_localctx, 6);
{
setState(2457);
pointerliteral();
}
break;
case Userdefinedintegerliteral:
case Userdefinedfloatingliteral:
case Userdefinedstringliteral:
case Userdefinedcharacterliteral:
enterOuterAlt(_localctx, 7);
{
setState(2458);
userdefinedliteral();
}
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 BooleanliteralContext extends ParserRuleContext {
public TerminalNode False() { return getToken(CPP14Parser.False, 0); }
public TerminalNode True() { return getToken(CPP14Parser.True, 0); }
public BooleanliteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_booleanliteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterBooleanliteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitBooleanliteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitBooleanliteral(this);
else return visitor.visitChildren(this);
}
}
public final BooleanliteralContext booleanliteral() throws RecognitionException {
BooleanliteralContext _localctx = new BooleanliteralContext(_ctx, getState());
enterRule(_localctx, 392, RULE_booleanliteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2461);
_la = _input.LA(1);
if ( !(_la==False || _la==True) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PointerliteralContext extends ParserRuleContext {
public TerminalNode Nullptr() { return getToken(CPP14Parser.Nullptr, 0); }
public PointerliteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pointerliteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterPointerliteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitPointerliteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitPointerliteral(this);
else return visitor.visitChildren(this);
}
}
public final PointerliteralContext pointerliteral() throws RecognitionException {
PointerliteralContext _localctx = new PointerliteralContext(_ctx, getState());
enterRule(_localctx, 394, RULE_pointerliteral);
try {
enterOuterAlt(_localctx, 1);
{
setState(2463);
match(Nullptr);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UserdefinedliteralContext extends ParserRuleContext {
public TerminalNode Userdefinedintegerliteral() { return getToken(CPP14Parser.Userdefinedintegerliteral, 0); }
public TerminalNode Userdefinedfloatingliteral() { return getToken(CPP14Parser.Userdefinedfloatingliteral, 0); }
public TerminalNode Userdefinedstringliteral() { return getToken(CPP14Parser.Userdefinedstringliteral, 0); }
public TerminalNode Userdefinedcharacterliteral() { return getToken(CPP14Parser.Userdefinedcharacterliteral, 0); }
public UserdefinedliteralContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_userdefinedliteral; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).enterUserdefinedliteral(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CPP14Listener ) ((CPP14Listener)listener).exitUserdefinedliteral(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CPP14Visitor ) return ((CPP14Visitor)visitor).visitUserdefinedliteral(this);
else return visitor.visitChildren(this);
}
}
public final UserdefinedliteralContext userdefinedliteral() throws RecognitionException {
UserdefinedliteralContext _localctx = new UserdefinedliteralContext(_ctx, getState());
enterRule(_localctx, 396, RULE_userdefinedliteral);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(2465);
_la = _input.LA(1);
if ( !(((((_la - 135)) & ~0x3f) == 0 && ((1L << (_la - 135)) & ((1L << (Userdefinedintegerliteral - 135)) | (1L << (Userdefinedfloatingliteral - 135)) | (1L << (Userdefinedstringliteral - 135)) | (1L << (Userdefinedcharacterliteral - 135)))) != 0)) ) {
_errHandler.recoverInline(this);
} else {
consume();
}
}
}
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 5:
return nestednamespecifier_sempred((NestednamespecifierContext)_localctx, predIndex);
case 10:
return capturelist_sempred((CapturelistContext)_localctx, predIndex);
case 15:
return postfixexpression_sempred((PostfixexpressionContext)_localctx, predIndex);
case 24:
return noptrnewdeclarator_sempred((NoptrnewdeclaratorContext)_localctx, predIndex);
case 29:
return pmexpression_sempred((PmexpressionContext)_localctx, predIndex);
case 30:
return multiplicativeexpression_sempred((MultiplicativeexpressionContext)_localctx, predIndex);
case 31:
return additiveexpression_sempred((AdditiveexpressionContext)_localctx, predIndex);
case 32:
return shiftexpression_sempred((ShiftexpressionContext)_localctx, predIndex);
case 33:
return relationalexpression_sempred((RelationalexpressionContext)_localctx, predIndex);
case 34:
return equalityexpression_sempred((EqualityexpressionContext)_localctx, predIndex);
case 35:
return andexpression_sempred((AndexpressionContext)_localctx, predIndex);
case 36:
return exclusiveorexpression_sempred((ExclusiveorexpressionContext)_localctx, predIndex);
case 37:
return inclusiveorexpression_sempred((InclusiveorexpressionContext)_localctx, predIndex);
case 38:
return logicalandexpression_sempred((LogicalandexpressionContext)_localctx, predIndex);
case 39:
return logicalorexpression_sempred((LogicalorexpressionContext)_localctx, predIndex);
case 43:
return expression_sempred((ExpressionContext)_localctx, predIndex);
case 49:
return statementseq_sempred((StatementseqContext)_localctx, predIndex);
case 58:
return declarationseq_sempred((DeclarationseqContext)_localctx, predIndex);
case 85:
return enumeratorlist_sempred((EnumeratorlistContext)_localctx, predIndex);
case 103:
return attributespecifierseq_sempred((AttributespecifierseqContext)_localctx, predIndex);
case 106:
return attributelist_sempred((AttributelistContext)_localctx, predIndex);
case 112:
return balancedtokenseq_sempred((BalancedtokenseqContext)_localctx, predIndex);
case 114:
return initdeclaratorlist_sempred((InitdeclaratorlistContext)_localctx, predIndex);
case 118:
return noptrdeclarator_sempred((NoptrdeclaratorContext)_localctx, predIndex);
case 129:
return noptrabstractdeclarator_sempred((NoptrabstractdeclaratorContext)_localctx, predIndex);
case 131:
return noptrabstractpackdeclarator_sempred((NoptrabstractpackdeclaratorContext)_localctx, predIndex);
case 133:
return parameterdeclarationlist_sempred((ParameterdeclarationlistContext)_localctx, predIndex);
case 140:
return initializerlist_sempred((InitializerlistContext)_localctx, predIndex);
case 150:
return memberdeclaratorlist_sempred((MemberdeclaratorlistContext)_localctx, predIndex);
case 152:
return virtspecifierseq_sempred((VirtspecifierseqContext)_localctx, predIndex);
case 156:
return basespecifierlist_sempred((BasespecifierlistContext)_localctx, predIndex);
case 171:
return templateparameterlist_sempred((TemplateparameterlistContext)_localctx, predIndex);
case 177:
return templateargumentlist_sempred((TemplateargumentlistContext)_localctx, predIndex);
case 190:
return typeidlist_sempred((TypeidlistContext)_localctx, predIndex);
}
return true;
}
private boolean nestednamespecifier_sempred(NestednamespecifierContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 2);
case 1:
return precpred(_ctx, 1);
}
return true;
}
private boolean capturelist_sempred(CapturelistContext _localctx, int predIndex) {
switch (predIndex) {
case 2:
return precpred(_ctx, 1);
}
return true;
}
private boolean postfixexpression_sempred(PostfixexpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 3:
return precpred(_ctx, 19);
case 4:
return precpred(_ctx, 18);
case 5:
return precpred(_ctx, 17);
case 6:
return precpred(_ctx, 12);
case 7:
return precpred(_ctx, 11);
case 8:
return precpred(_ctx, 10);
case 9:
return precpred(_ctx, 9);
case 10:
return precpred(_ctx, 8);
case 11:
return precpred(_ctx, 7);
}
return true;
}
private boolean noptrnewdeclarator_sempred(NoptrnewdeclaratorContext _localctx, int predIndex) {
switch (predIndex) {
case 12:
return precpred(_ctx, 1);
}
return true;
}
private boolean pmexpression_sempred(PmexpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 13:
return precpred(_ctx, 2);
case 14:
return precpred(_ctx, 1);
}
return true;
}
private boolean multiplicativeexpression_sempred(MultiplicativeexpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 15:
return precpred(_ctx, 3);
case 16:
return precpred(_ctx, 2);
case 17:
return precpred(_ctx, 1);
}
return true;
}
private boolean additiveexpression_sempred(AdditiveexpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 18:
return precpred(_ctx, 2);
case 19:
return precpred(_ctx, 1);
}
return true;
}
private boolean shiftexpression_sempred(ShiftexpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 20:
return precpred(_ctx, 2);
case 21:
return precpred(_ctx, 1);
}
return true;
}
private boolean relationalexpression_sempred(RelationalexpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 22:
return precpred(_ctx, 4);
case 23:
return precpred(_ctx, 3);
case 24:
return precpred(_ctx, 2);
case 25:
return precpred(_ctx, 1);
}
return true;
}
private boolean equalityexpression_sempred(EqualityexpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 26:
return precpred(_ctx, 2);
case 27:
return precpred(_ctx, 1);
}
return true;
}
private boolean andexpression_sempred(AndexpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 28:
return precpred(_ctx, 1);
}
return true;
}
private boolean exclusiveorexpression_sempred(ExclusiveorexpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 29:
return precpred(_ctx, 1);
}
return true;
}
private boolean inclusiveorexpression_sempred(InclusiveorexpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 30:
return precpred(_ctx, 1);
}
return true;
}
private boolean logicalandexpression_sempred(LogicalandexpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 31:
return precpred(_ctx, 1);
}
return true;
}
private boolean logicalorexpression_sempred(LogicalorexpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 32:
return precpred(_ctx, 1);
}
return true;
}
private boolean expression_sempred(ExpressionContext _localctx, int predIndex) {
switch (predIndex) {
case 33:
return precpred(_ctx, 1);
}
return true;
}
private boolean statementseq_sempred(StatementseqContext _localctx, int predIndex) {
switch (predIndex) {
case 34:
return precpred(_ctx, 1);
}
return true;
}
private boolean declarationseq_sempred(DeclarationseqContext _localctx, int predIndex) {
switch (predIndex) {
case 35:
return precpred(_ctx, 1);
}
return true;
}
private boolean enumeratorlist_sempred(EnumeratorlistContext _localctx, int predIndex) {
switch (predIndex) {
case 36:
return precpred(_ctx, 1);
}
return true;
}
private boolean attributespecifierseq_sempred(AttributespecifierseqContext _localctx, int predIndex) {
switch (predIndex) {
case 37:
return precpred(_ctx, 1);
}
return true;
}
private boolean attributelist_sempred(AttributelistContext _localctx, int predIndex) {
switch (predIndex) {
case 38:
return precpred(_ctx, 3);
case 39:
return precpred(_ctx, 1);
}
return true;
}
private boolean balancedtokenseq_sempred(BalancedtokenseqContext _localctx, int predIndex) {
switch (predIndex) {
case 40:
return precpred(_ctx, 1);
}
return true;
}
private boolean initdeclaratorlist_sempred(InitdeclaratorlistContext _localctx, int predIndex) {
switch (predIndex) {
case 41:
return precpred(_ctx, 1);
}
return true;
}
private boolean noptrdeclarator_sempred(NoptrdeclaratorContext _localctx, int predIndex) {
switch (predIndex) {
case 42:
return precpred(_ctx, 3);
case 43:
return precpred(_ctx, 2);
}
return true;
}
private boolean noptrabstractdeclarator_sempred(NoptrabstractdeclaratorContext _localctx, int predIndex) {
switch (predIndex) {
case 44:
return precpred(_ctx, 5);
case 45:
return precpred(_ctx, 3);
}
return true;
}
private boolean noptrabstractpackdeclarator_sempred(NoptrabstractpackdeclaratorContext _localctx, int predIndex) {
switch (predIndex) {
case 46:
return precpred(_ctx, 3);
case 47:
return precpred(_ctx, 2);
}
return true;
}
private boolean parameterdeclarationlist_sempred(ParameterdeclarationlistContext _localctx, int predIndex) {
switch (predIndex) {
case 48:
return precpred(_ctx, 1);
}
return true;
}
private boolean initializerlist_sempred(InitializerlistContext _localctx, int predIndex) {
switch (predIndex) {
case 49:
return precpred(_ctx, 1);
}
return true;
}
private boolean memberdeclaratorlist_sempred(MemberdeclaratorlistContext _localctx, int predIndex) {
switch (predIndex) {
case 50:
return precpred(_ctx, 1);
}
return true;
}
private boolean virtspecifierseq_sempred(VirtspecifierseqContext _localctx, int predIndex) {
switch (predIndex) {
case 51:
return precpred(_ctx, 1);
}
return true;
}
private boolean basespecifierlist_sempred(BasespecifierlistContext _localctx, int predIndex) {
switch (predIndex) {
case 52:
return precpred(_ctx, 1);
}
return true;
}
private boolean templateparameterlist_sempred(TemplateparameterlistContext _localctx, int predIndex) {
switch (predIndex) {
case 53:
return precpred(_ctx, 1);
}
return true;
}
private boolean templateargumentlist_sempred(TemplateargumentlistContext _localctx, int predIndex) {
switch (predIndex) {
case 54:
return precpred(_ctx, 1);
}
return true;
}
private boolean typeidlist_sempred(TypeidlistContext _localctx, int predIndex) {
switch (predIndex) {
case 55:
return precpred(_ctx, 1);
}
return true;
}
private static final int _serializedATNSegments = 2;
private static final String _serializedATNSegment0 =
"\3\u0430\ud6d1\u8206\uad2d\u4417\uaef1\u8d80\uaadd\3\u0090\u09a6\4\2\t"+
"\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
"w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+
"\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+
"\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+
"\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+
"\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+
"\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097"+
"\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b"+
"\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0"+
"\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4"+
"\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9"+
"\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad"+
"\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1\4\u00b2"+
"\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5\t\u00b5\4\u00b6\t\u00b6"+
"\4\u00b7\t\u00b7\4\u00b8\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb"+
"\t\u00bb\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\4\u00bf\t\u00bf"+
"\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2\4\u00c3\t\u00c3\4\u00c4"+
"\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6\4\u00c7\t\u00c7\4\u00c8\t\u00c8"+
"\3\2\5\2\u0192\n\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u019e\n"+
"\3\3\4\3\4\5\4\u01a2\n\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\5\5\u01ad"+
"\n\5\3\6\3\6\5\6\u01b1\n\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7"+
"\3\7\3\7\5\7\u01c0\n\7\3\7\3\7\3\7\3\7\3\7\5\7\u01c7\n\7\3\7\3\7\3\7\7"+
"\7\u01cc\n\7\f\7\16\7\u01cf\13\7\3\b\3\b\5\b\u01d3\n\b\3\b\3\b\3\t\3\t"+
"\5\t\u01d9\n\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u01e3\n\n\3\13\3\13"+
"\3\f\3\f\3\f\5\f\u01ea\n\f\3\f\3\f\3\f\3\f\5\f\u01f0\n\f\7\f\u01f2\n\f"+
"\f\f\16\f\u01f5\13\f\3\r\3\r\5\r\u01f9\n\r\3\16\3\16\3\16\3\16\5\16\u01ff"+
"\n\16\3\17\3\17\3\17\3\17\3\17\5\17\u0206\n\17\3\20\3\20\3\20\3\20\5\20"+
"\u020c\n\20\3\20\5\20\u020f\n\20\3\20\5\20\u0212\n\20\3\20\5\20\u0215"+
"\n\20\3\21\3\21\3\21\3\21\3\21\5\21\u021c\n\21\3\21\3\21\3\21\3\21\3\21"+
"\5\21\u0223\n\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21"+
"\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21"+
"\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21"+
"\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u0257\n\21"+
"\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21"+
"\u0266\n\21\3\21\3\21\3\21\3\21\5\21\u026c\n\21\3\21\3\21\3\21\3\21\5"+
"\21\u0272\n\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21"+
"\7\21\u027f\n\21\f\21\16\21\u0282\13\21\3\22\3\22\3\23\5\23\u0287\n\23"+
"\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\5\23"+
"\u0296\n\23\3\23\3\23\3\23\3\23\5\23\u029c\n\23\3\24\3\24\3\24\3\24\3"+
"\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3"+
"\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\5\24\u02ba\n\24\3\25"+
"\3\25\3\26\5\26\u02bf\n\26\3\26\3\26\5\26\u02c3\n\26\3\26\3\26\5\26\u02c7"+
"\n\26\3\26\5\26\u02ca\n\26\3\26\3\26\5\26\u02ce\n\26\3\26\3\26\3\26\3"+
"\26\5\26\u02d4\n\26\5\26\u02d6\n\26\3\27\3\27\3\27\3\27\3\30\3\30\5\30"+
"\u02de\n\30\3\31\3\31\5\31\u02e2\n\31\3\31\5\31\u02e5\n\31\3\32\3\32\3"+
"\32\3\32\3\32\5\32\u02ec\n\32\3\32\3\32\3\32\3\32\3\32\5\32\u02f3\n\32"+
"\7\32\u02f5\n\32\f\32\16\32\u02f8\13\32\3\33\3\33\5\33\u02fc\n\33\3\33"+
"\3\33\5\33\u0300\n\33\3\34\5\34\u0303\n\34\3\34\3\34\3\34\5\34\u0308\n"+
"\34\3\34\3\34\3\34\3\34\5\34\u030e\n\34\3\35\3\35\3\35\3\35\3\35\3\36"+
"\3\36\3\36\3\36\3\36\3\36\5\36\u031b\n\36\3\37\3\37\3\37\3\37\3\37\3\37"+
"\3\37\3\37\3\37\7\37\u0326\n\37\f\37\16\37\u0329\13\37\3 \3 \3 \3 \3 "+
"\3 \3 \3 \3 \3 \3 \3 \7 \u0337\n \f \16 \u033a\13 \3!\3!\3!\3!\3!\3!\3"+
"!\3!\3!\7!\u0345\n!\f!\16!\u0348\13!\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3\"\3"+
"\"\3\"\7\"\u0354\n\"\f\"\16\"\u0357\13\"\3#\3#\3#\3#\3#\3#\3#\3#\3#\3"+
"#\3#\3#\3#\3#\3#\7#\u0368\n#\f#\16#\u036b\13#\3$\3$\3$\3$\3$\3$\3$\3$"+
"\3$\7$\u0376\n$\f$\16$\u0379\13$\3%\3%\3%\3%\3%\3%\7%\u0381\n%\f%\16%"+
"\u0384\13%\3&\3&\3&\3&\3&\3&\7&\u038c\n&\f&\16&\u038f\13&\3\'\3\'\3\'"+
"\3\'\3\'\3\'\7\'\u0397\n\'\f\'\16\'\u039a\13\'\3(\3(\3(\3(\3(\3(\7(\u03a2"+
"\n(\f(\16(\u03a5\13(\3)\3)\3)\3)\3)\3)\7)\u03ad\n)\f)\16)\u03b0\13)\3"+
"*\3*\3*\3*\3*\3*\3*\5*\u03b9\n*\3+\3+\3+\3+\3+\3+\5+\u03c1\n+\3,\3,\3"+
",\3,\3,\3,\3,\3,\3,\3,\3,\5,\u03ce\n,\3-\3-\3-\3-\3-\3-\7-\u03d6\n-\f"+
"-\16-\u03d9\13-\3.\3.\3/\3/\5/\u03df\n/\3/\3/\5/\u03e3\n/\3/\3/\5/\u03e7"+
"\n/\3/\3/\5/\u03eb\n/\3/\3/\5/\u03ef\n/\3/\3/\3/\5/\u03f4\n/\3/\5/\u03f7"+
"\n/\3\60\5\60\u03fa\n\60\3\60\3\60\3\60\3\60\5\60\u0400\n\60\3\60\3\60"+
"\3\60\3\60\3\60\3\60\5\60\u0408\n\60\3\60\3\60\3\60\5\60\u040d\n\60\3"+
"\61\5\61\u0410\n\61\3\61\3\61\3\62\3\62\5\62\u0416\n\62\3\62\3\62\3\63"+
"\3\63\3\63\3\63\3\63\7\63\u041f\n\63\f\63\16\63\u0422\13\63\3\64\3\64"+
"\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64"+
"\3\64\3\64\3\64\3\64\5\64\u0438\n\64\3\65\3\65\5\65\u043c\n\65\3\65\3"+
"\65\3\65\3\65\3\65\3\65\5\65\u0444\n\65\3\65\3\65\3\65\3\65\5\65\u044a"+
"\n\65\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66"+
"\3\66\3\66\3\66\3\66\3\66\5\66\u045e\n\66\3\66\3\66\5\66\u0462\n\66\3"+
"\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\5\66\u046f\n\66"+
"\3\67\3\67\5\67\u0473\n\67\38\58\u0476\n8\38\38\38\39\39\59\u047d\n9\3"+
":\3:\3:\3:\3:\3:\5:\u0485\n:\3:\3:\3:\3:\3:\3:\3:\3:\5:\u048f\n:\3;\3"+
";\3<\3<\3<\3<\3<\7<\u0498\n<\f<\16<\u049b\13<\3=\3=\3=\3=\3=\3=\3=\3="+
"\3=\5=\u04a6\n=\3>\3>\3>\3>\3>\3>\3>\3>\5>\u04b0\n>\3?\3?\3?\5?\u04b5"+
"\n?\3?\3?\3?\3?\3@\5@\u04bc\n@\3@\5@\u04bf\n@\3@\3@\3@\5@\u04c4\n@\3@"+
"\3@\3@\5@\u04c9\n@\3A\3A\3A\3A\3A\3A\3A\3A\3B\3B\3C\3C\3C\3D\3D\3D\3D"+
"\3D\3D\5D\u04de\nD\3E\3E\5E\u04e2\nE\3E\3E\3E\5E\u04e7\nE\3F\3F\3G\3G"+
"\3H\3H\3I\3I\3I\5I\u04f2\nI\3J\3J\3J\3J\5J\u04f8\nJ\3K\3K\5K\u04fc\nK"+
"\3K\3K\3K\5K\u0501\nK\3L\3L\5L\u0505\nL\3L\3L\3L\5L\u050a\nL\3M\5M\u050d"+
"\nM\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\3M\5M\u0523"+
"\nM\3N\3N\3N\3N\5N\u0529\nN\3O\3O\3O\3O\3O\3O\3O\3O\3O\5O\u0534\nO\3P"+
"\3P\5P\u0538\nP\3P\5P\u053b\nP\3P\3P\3P\3P\3P\3P\3P\3P\5P\u0545\nP\3P"+
"\3P\3P\3P\5P\u054b\nP\3P\5P\u054e\nP\3Q\3Q\3R\3R\3R\5R\u0555\nR\3R\3R"+
"\3R\3R\3R\3R\3R\3R\5R\u055f\nR\3S\3S\5S\u0563\nS\3S\5S\u0566\nS\3S\5S"+
"\u0569\nS\3S\3S\5S\u056d\nS\3S\3S\3S\5S\u0572\nS\5S\u0574\nS\3T\3T\5T"+
"\u0578\nT\3T\3T\5T\u057c\nT\3T\3T\3U\3U\3U\3U\3U\5U\u0585\nU\3V\3V\3V"+
"\3W\3W\3W\3W\3W\3W\7W\u0590\nW\fW\16W\u0593\13W\3X\3X\3X\3X\3X\5X\u059a"+
"\nX\3Y\3Y\3Z\3Z\5Z\u05a0\nZ\3[\3[\3\\\3\\\5\\\u05a6\n\\\3]\3]\5]\u05aa"+
"\n]\3^\5^\u05ad\n^\3^\3^\3^\3^\3^\3^\3_\5_\u05b6\n_\3_\3_\3_\3_\3_\3_"+
"\3`\5`\u05bf\n`\3`\3`\3`\3`\3`\3a\5a\u05c7\na\3b\3b\3c\3c\3c\3c\3c\3c"+
"\3d\5d\u05d2\nd\3d\3d\3e\3e\5e\u05d8\ne\3e\3e\3e\3e\3e\3e\3e\3e\3e\5e"+
"\u05e3\ne\3f\5f\u05e6\nf\3f\3f\3f\5f\u05eb\nf\3f\3f\3f\3g\3g\3g\3g\3g"+
"\3g\3h\3h\3h\3h\5h\u05fa\nh\3h\3h\3h\3h\5h\u0600\nh\3i\3i\3i\3i\3i\7i"+
"\u0607\ni\fi\16i\u060a\13i\3j\3j\3j\3j\3j\3j\3j\5j\u0613\nj\3k\3k\3k\3"+
"k\5k\u0619\nk\3k\3k\3k\3k\3k\3k\5k\u0621\nk\3k\3k\5k\u0625\nk\3l\3l\5"+
"l\u0629\nl\3l\3l\3l\5l\u062e\nl\3l\3l\3l\5l\u0633\nl\3l\3l\3l\3l\3l\7"+
"l\u063a\nl\fl\16l\u063d\13l\3m\3m\5m\u0641\nm\3n\3n\5n\u0645\nn\3o\3o"+
"\3o\3o\3p\3p\3q\3q\3q\3q\3r\3r\5r\u0653\nr\3r\3r\7r\u0657\nr\fr\16r\u065a"+
"\13r\3s\3s\3s\3s\3s\3s\3s\3s\3s\3s\3s\3s\5s\u0668\ns\3t\3t\3t\3t\3t\3"+
"t\7t\u0670\nt\ft\16t\u0673\13t\3u\3u\5u\u0677\nu\3v\3v\3v\3v\3v\5v\u067e"+
"\nv\3w\3w\3w\3w\5w\u0684\nw\3x\3x\3x\5x\u0689\nx\3x\3x\3x\3x\5x\u068f"+
"\nx\3x\3x\3x\3x\3x\5x\u0696\nx\3x\3x\5x\u069a\nx\7x\u069c\nx\fx\16x\u069f"+
"\13x\3y\3y\3y\3y\5y\u06a5\ny\3y\5y\u06a8\ny\3y\5y\u06ab\ny\3y\5y\u06ae"+
"\ny\3z\3z\3z\5z\u06b3\nz\3{\3{\5{\u06b7\n{\3{\5{\u06ba\n{\3{\3{\5{\u06be"+
"\n{\3{\3{\5{\u06c2\n{\3{\3{\3{\5{\u06c7\n{\3{\5{\u06ca\n{\5{\u06cc\n{"+
"\3|\3|\5|\u06d0\n|\3}\3}\3~\3~\3\177\5\177\u06d7\n\177\3\177\3\177\3\u0080"+
"\3\u0080\5\u0080\u06dd\n\u0080\3\u0081\3\u0081\5\u0081\u06e1\n\u0081\3"+
"\u0081\3\u0081\3\u0081\3\u0081\5\u0081\u06e7\n\u0081\3\u0082\3\u0082\3"+
"\u0082\5\u0082\u06ec\n\u0082\5\u0082\u06ee\n\u0082\3\u0083\3\u0083\3\u0083"+
"\3\u0083\5\u0083\u06f4\n\u0083\3\u0083\3\u0083\5\u0083\u06f8\n\u0083\3"+
"\u0083\3\u0083\3\u0083\3\u0083\5\u0083\u06fe\n\u0083\3\u0083\3\u0083\3"+
"\u0083\3\u0083\3\u0083\5\u0083\u0705\n\u0083\3\u0083\3\u0083\5\u0083\u0709"+
"\n\u0083\7\u0083\u070b\n\u0083\f\u0083\16\u0083\u070e\13\u0083\3\u0084"+
"\3\u0084\3\u0084\3\u0084\5\u0084\u0714\n\u0084\3\u0085\3\u0085\3\u0085"+
"\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\5\u0085\u071e\n\u0085\3\u0085"+
"\3\u0085\5\u0085\u0722\n\u0085\7\u0085\u0724\n\u0085\f\u0085\16\u0085"+
"\u0727\13\u0085\3\u0086\5\u0086\u072a\n\u0086\3\u0086\5\u0086\u072d\n"+
"\u0086\3\u0086\3\u0086\3\u0086\3\u0086\5\u0086\u0733\n\u0086\3\u0087\3"+
"\u0087\3\u0087\3\u0087\3\u0087\3\u0087\7\u0087\u073b\n\u0087\f\u0087\16"+
"\u0087\u073e\13\u0087\3\u0088\5\u0088\u0741\n\u0088\3\u0088\3\u0088\3"+
"\u0088\3\u0088\5\u0088\u0747\n\u0088\3\u0088\3\u0088\3\u0088\3\u0088\3"+
"\u0088\3\u0088\5\u0088\u074f\n\u0088\3\u0088\3\u0088\5\u0088\u0753\n\u0088"+
"\3\u0088\5\u0088\u0756\n\u0088\3\u0088\3\u0088\5\u0088\u075a\n\u0088\3"+
"\u0088\3\u0088\3\u0088\5\u0088\u075f\n\u0088\3\u0089\5\u0089\u0762\n\u0089"+
"\3\u0089\5\u0089\u0765\n\u0089\3\u0089\3\u0089\5\u0089\u0769\n\u0089\3"+
"\u0089\3\u0089\3\u008a\5\u008a\u076e\n\u008a\3\u008a\3\u008a\3\u008a\3"+
"\u008a\3\u008a\3\u008a\3\u008a\3\u008a\5\u008a\u0778\n\u008a\3\u008b\3"+
"\u008b\3\u008b\3\u008b\3\u008b\5\u008b\u077f\n\u008b\3\u008c\3\u008c\3"+
"\u008c\5\u008c\u0784\n\u008c\3\u008d\3\u008d\5\u008d\u0788\n\u008d\3\u008e"+
"\3\u008e\3\u008e\5\u008e\u078d\n\u008e\3\u008e\3\u008e\3\u008e\3\u008e"+
"\5\u008e\u0793\n\u008e\7\u008e\u0795\n\u008e\f\u008e\16\u008e\u0798\13"+
"\u008e\3\u008f\3\u008f\3\u008f\5\u008f\u079d\n\u008f\3\u008f\3\u008f\3"+
"\u008f\3\u008f\5\u008f\u07a3\n\u008f\3\u0090\3\u0090\5\u0090\u07a7\n\u0090"+
"\3\u0091\3\u0091\3\u0091\5\u0091\u07ac\n\u0091\3\u0091\3\u0091\3\u0092"+
"\3\u0092\5\u0092\u07b2\n\u0092\3\u0092\3\u0092\5\u0092\u07b6\n\u0092\3"+
"\u0092\5\u0092\u07b9\n\u0092\3\u0092\3\u0092\5\u0092\u07bd\n\u0092\3\u0092"+
"\5\u0092\u07c0\n\u0092\5\u0092\u07c2\n\u0092\3\u0093\5\u0093\u07c5\n\u0093"+
"\3\u0093\3\u0093\3\u0094\3\u0094\3\u0095\3\u0095\3\u0096\3\u0096\5\u0096"+
"\u07cf\n\u0096\3\u0096\3\u0096\3\u0096\5\u0096\u07d4\n\u0096\5\u0096\u07d6"+
"\n\u0096\3\u0097\5\u0097\u07d9\n\u0097\3\u0097\5\u0097\u07dc\n\u0097\3"+
"\u0097\5\u0097\u07df\n\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3"+
"\u0097\3\u0097\5\u0097\u07e8\n\u0097\3\u0098\3\u0098\3\u0098\3\u0098\3"+
"\u0098\3\u0098\7\u0098\u07f0\n\u0098\f\u0098\16\u0098\u07f3\13\u0098\3"+
"\u0099\3\u0099\5\u0099\u07f7\n\u0099\3\u0099\5\u0099\u07fa\n\u0099\3\u0099"+
"\3\u0099\5\u0099\u07fe\n\u0099\3\u0099\5\u0099\u0801\n\u0099\3\u0099\5"+
"\u0099\u0804\n\u0099\3\u0099\3\u0099\5\u0099\u0808\n\u0099\3\u009a\3\u009a"+
"\3\u009a\3\u009a\3\u009a\7\u009a\u080f\n\u009a\f\u009a\16\u009a\u0812"+
"\13\u009a\3\u009b\3\u009b\3\u009c\3\u009c\3\u009c\3\u009c\3\u009d\3\u009d"+
"\3\u009d\3\u009e\3\u009e\3\u009e\5\u009e\u0820\n\u009e\3\u009e\3\u009e"+
"\3\u009e\3\u009e\5\u009e\u0826\n\u009e\7\u009e\u0828\n\u009e\f\u009e\16"+
"\u009e\u082b\13\u009e\3\u009f\5\u009f\u082e\n\u009f\3\u009f\3\u009f\5"+
"\u009f\u0832\n\u009f\3\u009f\3\u009f\5\u009f\u0836\n\u009f\3\u009f\3\u009f"+
"\5\u009f\u083a\n\u009f\3\u009f\3\u009f\5\u009f\u083e\n\u009f\3\u009f\3"+
"\u009f\5\u009f\u0842\n\u009f\3\u00a0\5\u00a0\u0845\n\u00a0\3\u00a0\3\u00a0"+
"\5\u00a0\u0849\n\u00a0\3\u00a1\3\u00a1\3\u00a2\3\u00a2\3\u00a3\3\u00a3"+
"\3\u00a3\3\u00a4\3\u00a4\5\u00a4\u0854\n\u00a4\3\u00a5\3\u00a5\5\u00a5"+
"\u0858\n\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a7\3\u00a7\5\u00a7\u085f\n"+
"\u00a7\3\u00a7\3\u00a7\5\u00a7\u0863\n\u00a7\3\u00a7\3\u00a7\3\u00a7\5"+
"\u00a7\u0868\n\u00a7\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u086d\n\u00a8\3\u00a8"+
"\3\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u0874\n\u00a8\3\u00a9\3\u00a9"+
"\5\u00a9\u0878\n\u00a9\3\u00aa\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ab"+
"\3\u00ab\3\u00ab\5\u00ab\u0882\n\u00ab\3\u00ac\3\u00ac\3\u00ac\3\u00ac"+
"\3\u00ac\3\u00ac\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\3\u00ad\7\u00ad"+
"\u0890\n\u00ad\f\u00ad\16\u00ad\u0893\13\u00ad\3\u00ae\3\u00ae\5\u00ae"+
"\u0897\n\u00ae\3\u00af\3\u00af\5\u00af\u089b\n\u00af\3\u00af\5\u00af\u089e"+
"\n\u00af\3\u00af\3\u00af\5\u00af\u08a2\n\u00af\3\u00af\3\u00af\3\u00af"+
"\3\u00af\5\u00af\u08a8\n\u00af\3\u00af\5\u00af\u08ab\n\u00af\3\u00af\3"+
"\u00af\5\u00af\u08af\n\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3"+
"\u00af\3\u00af\3\u00af\5\u00af\u08b9\n\u00af\3\u00af\5\u00af\u08bc\n\u00af"+
"\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\3\u00af\5\u00af\u08c4\n\u00af"+
"\3\u00af\3\u00af\3\u00af\5\u00af\u08c9\n\u00af\3\u00b0\3\u00b0\3\u00b0"+
"\5\u00b0\u08ce\n\u00b0\3\u00b0\3\u00b0\3\u00b1\3\u00b1\3\u00b1\3\u00b1"+
"\5\u00b1\u08d6\n\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\3\u00b1\5\u00b1"+
"\u08dd\n\u00b1\3\u00b1\3\u00b1\5\u00b1\u08e1\n\u00b1\3\u00b2\3\u00b2\3"+
"\u00b3\3\u00b3\3\u00b3\5\u00b3\u08e8\n\u00b3\3\u00b3\3\u00b3\3\u00b3\3"+
"\u00b3\5\u00b3\u08ee\n\u00b3\7\u00b3\u08f0\n\u00b3\f\u00b3\16\u00b3\u08f3"+
"\13\u00b3\3\u00b4\3\u00b4\3\u00b4\5\u00b4\u08f8\n\u00b4\3\u00b5\3\u00b5"+
"\3\u00b5\3\u00b5\3\u00b5\3\u00b5\3\u00b5\5\u00b5\u0901\n\u00b5\3\u00b5"+
"\3\u00b5\5\u00b5\u0905\n\u00b5\3\u00b6\5\u00b6\u0908\n\u00b6\3\u00b6\3"+
"\u00b6\3\u00b6\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b8\3\u00b8"+
"\3\u00b8\3\u00b8\3\u00b9\3\u00b9\5\u00b9\u0918\n\u00b9\3\u00b9\3\u00b9"+
"\3\u00b9\3\u00ba\3\u00ba\5\u00ba\u091f\n\u00ba\3\u00bb\3\u00bb\3\u00bb"+
"\3\u00bb\3\u00bb\3\u00bb\3\u00bc\5\u00bc\u0928\n\u00bc\3\u00bc\3\u00bc"+
"\3\u00bc\3\u00bc\5\u00bc\u092e\n\u00bc\3\u00bc\3\u00bc\5\u00bc\u0932\n"+
"\u00bc\3\u00bc\5\u00bc\u0935\n\u00bc\3\u00bd\3\u00bd\5\u00bd\u0939\n\u00bd"+
"\3\u00be\3\u00be\5\u00be\u093d\n\u00be\3\u00bf\3\u00bf\3\u00bf\5\u00bf"+
"\u0942\n\u00bf\3\u00bf\3\u00bf\3\u00c0\3\u00c0\3\u00c0\5\u00c0\u0949\n"+
"\u00c0\3\u00c0\3\u00c0\3\u00c0\3\u00c0\5\u00c0\u094f\n\u00c0\7\u00c0\u0951"+
"\n\u00c0\f\u00c0\16\u00c0\u0954\13\u00c0\3\u00c1\3\u00c1\3\u00c1\3\u00c1"+
"\3\u00c1\3\u00c1\5\u00c1\u095c\n\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c3"+
"\3\u00c3\3\u00c3\3\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4"+
"\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4"+
"\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4"+
"\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4"+
"\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4"+
"\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c4\5\u00c4\u0995\n\u00c4"+
"\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\3\u00c5\5\u00c5\u099e"+
"\n\u00c5\3\u00c6\3\u00c6\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8\2$\f"+
"\26 \62<>@BDFHJLNPXdv\u00ac\u00d0\u00d6\u00e2\u00e6\u00ee\u0104\u0108"+
"\u010c\u011a\u012e\u0132\u013a\u0158\u0164\u017e\u00c9\2\4\6\b\n\f\16"+
"\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bd"+
"fhjlnprtvxz|~\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\u00be\u00c0\u00c2"+
"\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6\u00d8\u00da"+
"\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee\u00f0\u00f2"+
"\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106\u0108\u010a"+
"\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122"+
"\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0138\u013a"+
"\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c\u014e\u0150\u0152"+
"\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a"+
"\u016c\u016e\u0170\u0172\u0174\u0176\u0178\u017a\u017c\u017e\u0180\u0182"+
"\u0184\u0186\u0188\u018a\u018c\u018e\2\r\4\2\\\\``\4\2VX\\_\7\2\37\37"+
"**\64\64::AA\5\2\35\35\'\'KK\4\2\21\21MM\4\2\\\\qq\5\2\20\20==HH\4\2!"+
"!\60\60\3\2\61\63\4\2 CC\3\2\u0089\u008c\u0ac7\2\u0191\3\2\2\2\4\u019d"+
"\3\2\2\2\6\u01a1\3\2\2\2\b\u01ac\3\2\2\2\n\u01ae\3\2\2\2\f\u01bf\3\2\2"+
"\2\16\u01d0\3\2\2\2\20\u01d6\3\2\2\2\22\u01e2\3\2\2\2\24\u01e4\3\2\2\2"+
"\26\u01e6\3\2\2\2\30\u01f8\3\2\2\2\32\u01fe\3\2\2\2\34\u0205\3\2\2\2\36"+
"\u0207\3\2\2\2 \u0256\3\2\2\2\"\u0283\3\2\2\2$\u029b\3\2\2\2&\u02b9\3"+
"\2\2\2(\u02bb\3\2\2\2*\u02d5\3\2\2\2,\u02d7\3\2\2\2.\u02db\3\2\2\2\60"+
"\u02e4\3\2\2\2\62\u02e6\3\2\2\2\64\u02ff\3\2\2\2\66\u030d\3\2\2\28\u030f"+
"\3\2\2\2:\u031a\3\2\2\2<\u031c\3\2\2\2>\u032a\3\2\2\2@\u033b\3\2\2\2B"+
"\u0349\3\2\2\2D\u0358\3\2\2\2F\u036c\3\2\2\2H\u037a\3\2\2\2J\u0385\3\2"+
"\2\2L\u0390\3\2\2\2N\u039b\3\2\2\2P\u03a6\3\2\2\2R\u03b8\3\2\2\2T\u03c0"+
"\3\2\2\2V\u03cd\3\2\2\2X\u03cf\3\2\2\2Z\u03da\3\2\2\2\\\u03f6\3\2\2\2"+
"^\u040c\3\2\2\2`\u040f\3\2\2\2b\u0413\3\2\2\2d\u0419\3\2\2\2f\u0437\3"+
"\2\2\2h\u0449\3\2\2\2j\u046e\3\2\2\2l\u0472\3\2\2\2n\u0475\3\2\2\2p\u047c"+
"\3\2\2\2r\u048e\3\2\2\2t\u0490\3\2\2\2v\u0492\3\2\2\2x\u04a5\3\2\2\2z"+
"\u04af\3\2\2\2|\u04b1\3\2\2\2~\u04c8\3\2\2\2\u0080\u04ca\3\2\2\2\u0082"+
"\u04d2\3\2\2\2\u0084\u04d4\3\2\2\2\u0086\u04dd\3\2\2\2\u0088\u04e6\3\2"+
"\2\2\u008a\u04e8\3\2\2\2\u008c\u04ea\3\2\2\2\u008e\u04ec\3\2\2\2\u0090"+
"\u04f1\3\2\2\2\u0092\u04f7\3\2\2\2\u0094\u0500\3\2\2\2\u0096\u0509\3\2"+
"\2\2\u0098\u0522\3\2\2\2\u009a\u0528\3\2\2\2\u009c\u0533\3\2\2\2\u009e"+
"\u054d\3\2\2\2\u00a0\u054f\3\2\2\2\u00a2\u055e\3\2\2\2\u00a4\u0573\3\2"+
"\2\2\u00a6\u0575\3\2\2\2\u00a8\u0584\3\2\2\2\u00aa\u0586\3\2\2\2\u00ac"+
"\u0589\3\2\2\2\u00ae\u0599\3\2\2\2\u00b0\u059b\3\2\2\2\u00b2\u059f\3\2"+
"\2\2\u00b4\u05a1\3\2\2\2\u00b6\u05a5\3\2\2\2\u00b8\u05a9\3\2\2\2\u00ba"+
"\u05ac\3\2\2\2\u00bc\u05b5\3\2\2\2\u00be\u05be\3\2\2\2\u00c0\u05c6\3\2"+
"\2\2\u00c2\u05c8\3\2\2\2\u00c4\u05ca\3\2\2\2\u00c6\u05d1\3\2\2\2\u00c8"+
"\u05e2\3\2\2\2\u00ca\u05e5\3\2\2\2\u00cc\u05ef\3\2\2\2\u00ce\u05ff\3\2"+
"\2\2\u00d0\u0601\3\2\2\2\u00d2\u0612\3\2\2\2\u00d4\u0624\3\2\2\2\u00d6"+
"\u062d\3\2\2\2\u00d8\u063e\3\2\2\2\u00da\u0644\3\2\2\2\u00dc\u0646\3\2"+
"\2\2\u00de\u064a\3\2\2\2\u00e0\u064c\3\2\2\2\u00e2\u0650\3\2\2\2\u00e4"+
"\u0667\3\2\2\2\u00e6\u0669\3\2\2\2\u00e8\u0674\3\2\2\2\u00ea\u067d\3\2"+
"\2\2\u00ec\u0683\3\2\2\2\u00ee\u068e\3\2\2\2\u00f0\u06a0\3\2\2\2\u00f2"+
"\u06af\3\2\2\2\u00f4\u06cb\3\2\2\2\u00f6\u06cd\3\2\2\2\u00f8\u06d1\3\2"+
"\2\2\u00fa\u06d3\3\2\2\2\u00fc\u06d6\3\2\2\2\u00fe\u06da\3\2\2\2\u0100"+
"\u06e6\3\2\2\2\u0102\u06ed\3\2\2\2\u0104\u06fd\3\2\2\2\u0106\u0713\3\2"+
"\2\2\u0108\u0715\3\2\2\2\u010a\u0732\3\2\2\2\u010c\u0734\3\2\2\2\u010e"+
"\u075e\3\2\2\2\u0110\u0761\3\2\2\2\u0112\u0777\3\2\2\2\u0114\u077e\3\2"+
"\2\2\u0116\u0783\3\2\2\2\u0118\u0787\3\2\2\2\u011a\u0789\3\2\2\2\u011c"+
"\u07a2\3\2\2\2\u011e\u07a6\3\2\2\2\u0120\u07a8\3\2\2\2\u0122\u07c1\3\2"+
"\2\2\u0124\u07c4\3\2\2\2\u0126\u07c8\3\2\2\2\u0128\u07ca\3\2\2\2\u012a"+
"\u07d5\3\2\2\2\u012c\u07e7\3\2\2\2\u012e\u07e9\3\2\2\2\u0130\u0807\3\2"+
"\2\2\u0132\u0809\3\2\2\2\u0134\u0813\3\2\2\2\u0136\u0815\3\2\2\2\u0138"+
"\u0819\3\2\2\2\u013a\u081c\3\2\2\2\u013c\u0841\3\2\2\2\u013e\u0848\3\2"+
"\2\2\u0140\u084a\3\2\2\2\u0142\u084c\3\2\2\2\u0144\u084e\3\2\2\2\u0146"+
"\u0851\3\2\2\2\u0148\u0855\3\2\2\2\u014a\u0859\3\2\2\2\u014c\u0867\3\2"+
"\2\2\u014e\u0873\3\2\2\2\u0150\u0877\3\2\2\2\u0152\u0879\3\2\2\2\u0154"+
"\u0881\3\2\2\2\u0156\u0883\3\2\2\2\u0158\u0889\3\2\2\2\u015a\u0896\3\2"+
"\2\2\u015c\u08c8\3\2\2\2\u015e\u08ca\3\2\2\2\u0160\u08e0\3\2\2\2\u0162"+
"\u08e2\3\2\2\2\u0164\u08e4\3\2\2\2\u0166\u08f7\3\2\2\2\u0168\u0904\3\2"+
"\2\2\u016a\u0907\3\2\2\2\u016c\u090c\3\2\2\2\u016e\u0911\3\2\2\2\u0170"+
"\u0915\3\2\2\2\u0172\u091c\3\2\2\2\u0174\u0920\3\2\2\2\u0176\u0934\3\2"+
"\2\2\u0178\u0936\3\2\2\2\u017a\u093c\3\2\2\2\u017c\u093e\3\2\2\2\u017e"+
"\u0945\3\2\2\2\u0180\u095b\3\2\2\2\u0182\u095d\3\2\2\2\u0184\u0960\3\2"+
"\2\2\u0186\u0994\3\2\2\2\u0188\u099d\3\2\2\2\u018a\u099f\3\2\2\2\u018c"+
"\u09a1\3\2\2\2\u018e\u09a3\3\2\2\2\u0190\u0192\5v<\2\u0191\u0190\3\2\2"+
"\2\u0191\u0192\3\2\2\2\u0192\u0193\3\2\2\2\u0193\u0194\7\2\2\3\u0194\3"+
"\3\2\2\2\u0195\u019e\5\u0188\u00c5\2\u0196\u019e\7@\2\2\u0197\u0198\7"+
"P\2\2\u0198\u0199\5X-\2\u0199\u019a\7Q\2\2\u019a\u019e\3\2\2\2\u019b\u019e"+
"\5\6\4\2\u019c\u019e\5\16\b\2\u019d\u0195\3\2\2\2\u019d\u0196\3\2\2\2"+
"\u019d\u0197\3\2\2\2\u019d\u019b\3\2\2\2\u019d\u019c\3\2\2\2\u019e\5\3"+
"\2\2\2\u019f\u01a2\5\b\5\2\u01a0\u01a2\5\n\6\2\u01a1\u019f\3\2\2\2\u01a1"+
"\u01a0\3\2\2\2\u01a2\7\3\2\2\2\u01a3\u01ad\7\177\2\2\u01a4\u01ad\5\u0152"+
"\u00aa\2\u01a5\u01ad\5\u0144\u00a3\2\u01a6\u01ad\5\u0154\u00ab\2\u01a7"+
"\u01a8\7^\2\2\u01a8\u01ad\5\u011e\u0090\2\u01a9\u01aa\7^\2\2\u01aa\u01ad"+
"\5\u009cO\2\u01ab\u01ad\5\u0160\u00b1\2\u01ac\u01a3\3\2\2\2\u01ac\u01a4"+
"\3\2\2\2\u01ac\u01a5\3\2\2\2\u01ac\u01a6\3\2\2\2\u01ac\u01a7\3\2\2\2\u01ac"+
"\u01a9\3\2\2\2\u01ac\u01ab\3\2\2\2\u01ad\t\3\2\2\2\u01ae\u01b0\5\f\7\2"+
"\u01af\u01b1\7?\2\2\u01b0\u01af\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1\u01b2"+
"\3\2\2\2\u01b2\u01b3\5\b\5\2\u01b3\13\3\2\2\2\u01b4\u01b5\b\7\1\2\u01b5"+
"\u01c0\7z\2\2\u01b6\u01b7\5\u009aN\2\u01b7\u01b8\7z\2\2\u01b8\u01c0\3"+
"\2\2\2\u01b9\u01ba\5\u00b2Z\2\u01ba\u01bb\7z\2\2\u01bb\u01c0\3\2\2\2\u01bc"+
"\u01bd\5\u009cO\2\u01bd\u01be\7z\2\2\u01be\u01c0\3\2\2\2\u01bf\u01b4\3"+
"\2\2\2\u01bf\u01b6\3\2\2\2\u01bf\u01b9\3\2\2\2\u01bf\u01bc\3\2\2\2\u01c0"+
"\u01cd\3\2\2\2\u01c1\u01c2\f\4\2\2\u01c2\u01c3\7\177\2\2\u01c3\u01cc\7"+
"z\2\2\u01c4\u01c6\f\3\2\2\u01c5\u01c7\7?\2\2\u01c6\u01c5\3\2\2\2\u01c6"+
"\u01c7\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8\u01c9\5\u015e\u00b0\2\u01c9\u01ca"+
"\7z\2\2\u01ca\u01cc\3\2\2\2\u01cb\u01c1\3\2\2\2\u01cb\u01c4\3\2\2\2\u01cc"+
"\u01cf\3\2\2\2\u01cd\u01cb\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce\r\3\2\2\2"+
"\u01cf\u01cd\3\2\2\2\u01d0\u01d2\5\20\t\2\u01d1\u01d3\5\36\20\2\u01d2"+
"\u01d1\3\2\2\2\u01d2\u01d3\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4\u01d5\5b"+
"\62\2\u01d5\17\3\2\2\2\u01d6\u01d8\7R\2\2\u01d7\u01d9\5\22\n\2\u01d8\u01d7"+
"\3\2\2\2\u01d8\u01d9\3\2\2\2\u01d9\u01da\3\2\2\2\u01da\u01db\7S\2\2\u01db"+
"\21\3\2\2\2\u01dc\u01e3\5\24\13\2\u01dd\u01e3\5\26\f\2\u01de\u01df\5\24"+
"\13\2\u01df\u01e0\7u\2\2\u01e0\u01e1\5\26\f\2\u01e1\u01e3\3\2\2\2\u01e2"+
"\u01dc\3\2\2\2\u01e2\u01dd\3\2\2\2\u01e2\u01de\3\2\2\2\u01e3\23\3\2\2"+
"\2\u01e4\u01e5\t\2\2\2\u01e5\25\3\2\2\2\u01e6\u01e7\b\f\1\2\u01e7\u01e9"+
"\5\30\r\2\u01e8\u01ea\7~\2\2\u01e9\u01e8\3\2\2\2\u01e9\u01ea\3\2\2\2\u01ea"+
"\u01f3\3\2\2\2\u01eb\u01ec\f\3\2\2\u01ec\u01ed\7u\2\2\u01ed\u01ef\5\30"+
"\r\2\u01ee\u01f0\7~\2\2\u01ef\u01ee\3\2\2\2\u01ef\u01f0\3\2\2\2\u01f0"+
"\u01f2\3\2\2\2\u01f1\u01eb\3\2\2\2\u01f2\u01f5\3\2\2\2\u01f3\u01f1\3\2"+
"\2\2\u01f3\u01f4\3\2\2\2\u01f4\27\3\2\2\2\u01f5\u01f3\3\2\2\2\u01f6\u01f9"+
"\5\32\16\2\u01f7\u01f9\5\34\17\2\u01f8\u01f6\3\2\2\2\u01f8\u01f7\3\2\2"+
"\2\u01f9\31\3\2\2\2\u01fa\u01ff\7\177\2\2\u01fb\u01fc\7\\\2\2\u01fc\u01ff"+
"\7\177\2\2\u01fd\u01ff\7@\2\2\u01fe\u01fa\3\2\2\2\u01fe\u01fb\3\2\2\2"+
"\u01fe\u01fd\3\2\2\2\u01ff\33\3\2\2\2\u0200\u0201\7\177\2\2\u0201\u0206"+
"\5\u0114\u008b\2\u0202\u0203\7\\\2\2\u0203\u0204\7\177\2\2\u0204\u0206"+
"\5\u0114\u008b\2\u0205\u0200\3\2\2\2\u0205\u0202\3\2\2\2\u0206\35\3\2"+
"\2\2\u0207\u0208\7P\2\2\u0208\u0209\5\u010a\u0086\2\u0209\u020b\7Q\2\2"+
"\u020a\u020c\7*\2\2\u020b\u020a\3\2\2\2\u020b\u020c\3\2\2\2\u020c\u020e"+
"\3\2\2\2\u020d\u020f\5\u017a\u00be\2\u020e\u020d\3\2\2\2\u020e\u020f\3"+
"\2\2\2\u020f\u0211\3\2\2\2\u0210\u0212\5\u00d0i\2\u0211\u0210\3\2\2\2"+
"\u0211\u0212\3\2\2\2\u0212\u0214\3\2\2\2\u0213\u0215\5\u00f2z\2\u0214"+
"\u0213\3\2\2\2\u0214\u0215\3\2\2\2\u0215\37\3\2\2\2\u0216\u0217\b\21\1"+
"\2\u0217\u0257\5\4\3\2\u0218\u0219\5\u0098M\2\u0219\u021b\7P\2\2\u021a"+
"\u021c\5\"\22\2\u021b\u021a\3\2\2\2\u021b\u021c\3\2\2\2\u021c\u021d\3"+
"\2\2\2\u021d\u021e\7Q\2\2\u021e\u0257\3\2\2\2\u021f\u0220\5\u0168\u00b5"+
"\2\u0220\u0222\7P\2\2\u0221\u0223\5\"\22\2\u0222\u0221\3\2\2\2\u0222\u0223"+
"\3\2\2\2\u0223\u0224\3\2\2\2\u0224\u0225\7Q\2\2\u0225\u0257\3\2\2\2\u0226"+
"\u0227\5\u0098M\2\u0227\u0228\5\u011c\u008f\2\u0228\u0257\3\2\2\2\u0229"+
"\u022a\5\u0168\u00b5\2\u022a\u022b\5\u011c\u008f\2\u022b\u0257\3\2\2\2"+
"\u022c\u022d\7\32\2\2\u022d\u022e\7a\2\2\u022e\u022f\5\u00fe\u0080\2\u022f"+
"\u0230\7b\2\2\u0230\u0231\7P\2\2\u0231\u0232\5X-\2\u0232\u0233\7Q\2\2"+
"\u0233\u0257\3\2\2\2\u0234\u0235\7<\2\2\u0235\u0236\7a\2\2\u0236\u0237"+
"\5\u00fe\u0080\2\u0237\u0238\7b\2\2\u0238\u0239\7P\2\2\u0239\u023a\5X"+
"-\2\u023a\u023b\7Q\2\2\u023b\u0257\3\2\2\2\u023c\u023d\7\65\2\2\u023d"+
"\u023e\7a\2\2\u023e\u023f\5\u00fe\u0080\2\u023f\u0240\7b\2\2\u0240\u0241"+
"\7P\2\2\u0241\u0242\5X-\2\u0242\u0243\7Q\2\2\u0243\u0257\3\2\2\2\u0244"+
"\u0245\7\23\2\2\u0245\u0246\7a\2\2\u0246\u0247\5\u00fe\u0080\2\u0247\u0248"+
"\7b\2\2\u0248\u0249\7P\2\2\u0249\u024a\5X-\2\u024a\u024b\7Q\2\2\u024b"+
"\u0257\3\2\2\2\u024c\u024d\7F\2\2\u024d\u024e\7P\2\2\u024e\u024f\5X-\2"+
"\u024f\u0250\7Q\2\2\u0250\u0257\3\2\2\2\u0251\u0252\7F\2\2\u0252\u0253"+
"\7P\2\2\u0253\u0254\5\u00fe\u0080\2\u0254\u0255\7Q\2\2\u0255\u0257\3\2"+
"\2\2\u0256\u0216\3\2\2\2\u0256\u0218\3\2\2\2\u0256\u021f\3\2\2\2\u0256"+
"\u0226\3\2\2\2\u0256\u0229\3\2\2\2\u0256\u022c\3\2\2\2\u0256\u0234\3\2"+
"\2\2\u0256\u023c\3\2\2\2\u0256\u0244\3\2\2\2\u0256\u024c\3\2\2\2\u0256"+
"\u0251\3\2\2\2\u0257\u0280\3\2\2\2\u0258\u0259\f\25\2\2\u0259\u025a\7"+
"R\2\2\u025a\u025b\5X-\2\u025b\u025c\7S\2\2\u025c\u027f\3\2\2\2\u025d\u025e"+
"\f\24\2\2\u025e\u025f\7R\2\2\u025f\u0260\5\u011c\u008f\2\u0260\u0261\7"+
"S\2\2\u0261\u027f\3\2\2\2\u0262\u0263\f\23\2\2\u0263\u0265\7P\2\2\u0264"+
"\u0266\5\"\22\2\u0265\u0264\3\2\2\2\u0265\u0266\3\2\2\2\u0266\u0267\3"+
"\2\2\2\u0267\u027f\7Q\2\2\u0268\u0269\f\16\2\2\u0269\u026b\7|\2\2\u026a"+
"\u026c\7?\2\2\u026b\u026a\3\2\2\2\u026b\u026c\3\2\2\2\u026c\u026d\3\2"+
"\2\2\u026d\u027f\5\6\4\2\u026e\u026f\f\r\2\2\u026f\u0271\7w\2\2\u0270"+
"\u0272\7?\2\2\u0271\u0270\3\2\2\2\u0271\u0272\3\2\2\2\u0272\u0273\3\2"+
"\2\2\u0273\u027f\5\6\4\2\u0274\u0275\f\f\2\2\u0275\u0276\7|\2\2\u0276"+
"\u027f\5$\23\2\u0277\u0278\f\13\2\2\u0278\u0279\7w\2\2\u0279\u027f\5$"+
"\23\2\u027a\u027b\f\n\2\2\u027b\u027f\7s\2\2\u027c\u027d\f\t\2\2\u027d"+
"\u027f\7t\2\2\u027e\u0258\3\2\2\2\u027e\u025d\3\2\2\2\u027e\u0262\3\2"+
"\2\2\u027e\u0268\3\2\2\2\u027e\u026e\3\2\2\2\u027e\u0274\3\2\2\2\u027e"+
"\u0277\3\2\2\2\u027e\u027a\3\2\2\2\u027e\u027c\3\2\2\2\u027f\u0282\3\2"+
"\2\2\u0280\u027e\3\2\2\2\u0280\u0281\3\2\2\2\u0281!\3\2\2\2\u0282\u0280"+
"\3\2\2\2\u0283\u0284\5\u011a\u008e\2\u0284#\3\2\2\2\u0285\u0287\5\f\7"+
"\2\u0286\u0285\3\2\2\2\u0286\u0287\3\2\2\2\u0287\u0288\3\2\2\2\u0288\u0289"+
"\5\u009aN\2\u0289\u028a\7z\2\2\u028a\u028b\7^\2\2\u028b\u028c\5\u009a"+
"N\2\u028c\u029c\3\2\2\2\u028d\u028e\5\f\7\2\u028e\u028f\7?\2\2\u028f\u0290"+
"\5\u015e\u00b0\2\u0290\u0291\7z\2\2\u0291\u0292\7^\2\2\u0292\u0293\5\u009a"+
"N\2\u0293\u029c\3\2\2\2\u0294\u0296\5\f\7\2\u0295\u0294\3\2\2\2\u0295"+
"\u0296\3\2\2\2\u0296\u0297\3\2\2\2\u0297\u0298\7^\2\2\u0298\u029c\5\u009a"+
"N\2\u0299\u029a\7^\2\2\u029a\u029c\5\u009cO\2\u029b\u0286\3\2\2\2\u029b"+
"\u028d\3\2\2\2\u029b\u0295\3\2\2\2\u029b\u0299\3\2\2\2\u029c%\3\2\2\2"+
"\u029d\u02ba\5 \21\2\u029e\u029f\7s\2\2\u029f\u02ba\5:\36\2\u02a0\u02a1"+
"\7t\2\2\u02a1\u02ba\5:\36\2\u02a2\u02a3\5(\25\2\u02a3\u02a4\5:\36\2\u02a4"+
"\u02ba\3\2\2\2\u02a5\u02a6\79\2\2\u02a6\u02ba\5&\24\2\u02a7\u02a8\79\2"+
"\2\u02a8\u02a9\7P\2\2\u02a9\u02aa\5\u00fe\u0080\2\u02aa\u02ab\7Q\2\2\u02ab"+
"\u02ba\3\2\2\2\u02ac\u02ad\79\2\2\u02ad\u02ae\7~\2\2\u02ae\u02af\7P\2"+
"\2\u02af\u02b0\7\177\2\2\u02b0\u02ba\7Q\2\2\u02b1\u02b2\7\6\2\2\u02b2"+
"\u02b3\7P\2\2\u02b3\u02b4\5\u00fe\u0080\2\u02b4\u02b5\7Q\2\2\u02b5\u02ba"+
"\3\2\2\2\u02b6\u02ba\58\35\2\u02b7\u02ba\5*\26\2\u02b8\u02ba\5\66\34\2"+
"\u02b9\u029d\3\2\2\2\u02b9\u029e\3\2\2\2\u02b9\u02a0\3\2\2\2\u02b9\u02a2"+
"\3\2\2\2\u02b9\u02a5\3\2\2\2\u02b9\u02a7\3\2\2\2\u02b9\u02ac\3\2\2\2\u02b9"+
"\u02b1\3\2\2\2\u02b9\u02b6\3\2\2\2\u02b9\u02b7\3\2\2\2\u02b9\u02b8\3\2"+
"\2\2\u02ba\'\3\2\2\2\u02bb\u02bc\t\3\2\2\u02bc)\3\2\2\2\u02bd\u02bf\7"+
"z\2\2\u02be\u02bd\3\2\2\2\u02be\u02bf\3\2\2\2\u02bf\u02c0\3\2\2\2\u02c0"+
"\u02c2\7,\2\2\u02c1\u02c3\5,\27\2\u02c2\u02c1\3\2\2\2\u02c2\u02c3\3\2"+
"\2\2\u02c3\u02c4\3\2\2\2\u02c4\u02c6\5.\30\2\u02c5\u02c7\5\64\33\2\u02c6"+
"\u02c5\3\2\2\2\u02c6\u02c7\3\2\2\2\u02c7\u02d6\3\2\2\2\u02c8\u02ca\7z"+
"\2\2\u02c9\u02c8\3\2\2\2\u02c9\u02ca\3\2\2\2\u02ca\u02cb\3\2\2\2\u02cb"+
"\u02cd\7,\2\2\u02cc\u02ce\5,\27\2\u02cd\u02cc\3\2\2\2\u02cd\u02ce\3\2"+
"\2\2\u02ce\u02cf\3\2\2\2\u02cf\u02d0\7P\2\2\u02d0\u02d1\5\u00fe\u0080"+
"\2\u02d1\u02d3\7Q\2\2\u02d2\u02d4\5\64\33\2\u02d3\u02d2\3\2\2\2\u02d3"+
"\u02d4\3\2\2\2\u02d4\u02d6\3\2\2\2\u02d5\u02be\3\2\2\2\u02d5\u02c9\3\2"+
"\2\2\u02d6+\3\2\2\2\u02d7\u02d8\7P\2\2\u02d8\u02d9\5\"\22\2\u02d9\u02da"+
"\7Q\2\2\u02da-\3\2\2\2\u02db\u02dd\5\u0094K\2\u02dc\u02de\5\60\31\2\u02dd"+
"\u02dc\3\2\2\2\u02dd\u02de\3\2\2\2\u02de/\3\2\2\2\u02df\u02e1\5\u00f4"+
"{\2\u02e0\u02e2\5\60\31\2\u02e1\u02e0\3\2\2\2\u02e1\u02e2\3\2\2\2\u02e2"+
"\u02e5\3\2\2\2\u02e3\u02e5\5\62\32\2\u02e4\u02df\3\2\2\2\u02e4\u02e3\3"+
"\2\2\2\u02e5\61\3\2\2\2\u02e6\u02e7\b\32\1\2\u02e7\u02e8\7R\2\2\u02e8"+
"\u02e9\5X-\2\u02e9\u02eb\7S\2\2\u02ea\u02ec\5\u00d0i\2\u02eb\u02ea\3\2"+
"\2\2\u02eb\u02ec\3\2\2\2\u02ec\u02f6\3\2\2\2\u02ed\u02ee\f\3\2\2\u02ee"+
"\u02ef\7R\2\2\u02ef\u02f0\5Z.\2\u02f0\u02f2\7S\2\2\u02f1\u02f3\5\u00d0"+
"i\2\u02f2\u02f1\3\2\2\2\u02f2\u02f3\3\2\2\2\u02f3\u02f5\3\2\2\2\u02f4"+
"\u02ed\3\2\2\2\u02f5\u02f8\3\2\2\2\u02f6\u02f4\3\2\2\2\u02f6\u02f7\3\2"+
"\2\2\u02f7\63\3\2\2\2\u02f8\u02f6\3\2\2\2\u02f9\u02fb\7P\2\2\u02fa\u02fc"+
"\5\"\22\2\u02fb\u02fa\3\2\2\2\u02fb\u02fc\3\2\2\2\u02fc\u02fd\3\2\2\2"+
"\u02fd\u0300\7Q\2\2\u02fe\u0300\5\u011c\u008f\2\u02ff\u02f9\3\2\2\2\u02ff"+
"\u02fe\3\2\2\2\u0300\65\3\2\2\2\u0301\u0303\7z\2\2\u0302\u0301\3\2\2\2"+
"\u0302\u0303\3\2\2\2\u0303\u0304\3\2\2\2\u0304\u0305\7\27\2\2\u0305\u030e"+
"\5:\36\2\u0306\u0308\7z\2\2\u0307\u0306\3\2\2\2\u0307\u0308\3\2\2\2\u0308"+
"\u0309\3\2\2\2\u0309\u030a\7\27\2\2\u030a\u030b\7R\2\2\u030b\u030c\7S"+
"\2\2\u030c\u030e\5:\36\2\u030d\u0302\3\2\2\2\u030d\u0307\3\2\2\2\u030e"+
"\67\3\2\2\2\u030f\u0310\7-\2\2\u0310\u0311\7P\2\2\u0311\u0312\5X-\2\u0312"+
"\u0313\7Q\2\2\u03139\3\2\2\2\u0314\u031b\5&\24\2\u0315\u0316\7P\2\2\u0316"+
"\u0317\5\u00fe\u0080\2\u0317\u0318\7Q\2\2\u0318\u0319\5:\36\2\u0319\u031b"+
"\3\2\2\2\u031a\u0314\3\2\2\2\u031a\u0315\3\2\2\2\u031b;\3\2\2\2\u031c"+
"\u031d\b\37\1\2\u031d\u031e\5:\36\2\u031e\u0327\3\2\2\2\u031f\u0320\f"+
"\4\2\2\u0320\u0321\7}\2\2\u0321\u0326\5:\36\2\u0322\u0323\f\3\2\2\u0323"+
"\u0324\7v\2\2\u0324\u0326\5:\36\2\u0325\u031f\3\2\2\2\u0325\u0322\3\2"+
"\2\2\u0326\u0329\3\2\2\2\u0327\u0325\3\2\2\2\u0327\u0328\3\2\2\2\u0328"+
"=\3\2\2\2\u0329\u0327\3\2\2\2\u032a\u032b\b \1\2\u032b\u032c\5<\37\2\u032c"+
"\u0338\3\2\2\2\u032d\u032e\f\5\2\2\u032e\u032f\7X\2\2\u032f\u0337\5<\37"+
"\2\u0330\u0331\f\4\2\2\u0331\u0332\7Y\2\2\u0332\u0337\5<\37\2\u0333\u0334"+
"\f\3\2\2\u0334\u0335\7Z\2\2\u0335\u0337\5<\37\2\u0336\u032d\3\2\2\2\u0336"+
"\u0330\3\2\2\2\u0336\u0333\3\2\2\2\u0337\u033a\3\2\2\2\u0338\u0336\3\2"+
"\2\2\u0338\u0339\3\2\2\2\u0339?\3\2\2\2\u033a\u0338\3\2\2\2\u033b\u033c"+
"\b!\1\2\u033c\u033d\5> \2\u033d\u0346\3\2\2\2\u033e\u033f\f\4\2\2\u033f"+
"\u0340\7V\2\2\u0340\u0345\5> \2\u0341\u0342\f\3\2\2\u0342\u0343\7W\2\2"+
"\u0343\u0345\5> \2\u0344\u033e\3\2\2\2\u0344\u0341\3\2\2\2\u0345\u0348"+
"\3\2\2\2\u0346\u0344\3\2\2\2\u0346\u0347\3\2\2\2\u0347A\3\2\2\2\u0348"+
"\u0346\3\2\2\2\u0349\u034a\b\"\1\2\u034a\u034b\5@!\2\u034b\u0355\3\2\2"+
"\2\u034c\u034d\f\4\2\2\u034d\u034e\7k\2\2\u034e\u0354\5@!\2\u034f\u0350"+
"\f\3\2\2\u0350\u0351\5\u0182\u00c2\2\u0351\u0352\5@!\2\u0352\u0354\3\2"+
"\2\2\u0353\u034c\3\2\2\2\u0353\u034f\3\2\2\2\u0354\u0357\3\2\2\2\u0355"+
"\u0353\3\2\2\2\u0355\u0356\3\2\2\2\u0356C\3\2\2\2\u0357\u0355\3\2\2\2"+
"\u0358\u0359\b#\1\2\u0359\u035a\5B\"\2\u035a\u0369\3\2\2\2\u035b\u035c"+
"\f\6\2\2\u035c\u035d\7a\2\2\u035d\u0368\5B\"\2\u035e\u035f\f\5\2\2\u035f"+
"\u0360\7b\2\2\u0360\u0368\5B\"\2\u0361\u0362\f\4\2\2\u0362\u0363\7o\2"+
"\2\u0363\u0368\5B\"\2\u0364\u0365\f\3\2\2\u0365\u0366\7p\2\2\u0366\u0368"+
"\5B\"\2\u0367\u035b\3\2\2\2\u0367\u035e\3\2\2\2\u0367\u0361\3\2\2\2\u0367"+
"\u0364\3\2\2\2\u0368\u036b\3\2\2\2\u0369\u0367\3\2\2\2\u0369\u036a\3\2"+
"\2\2\u036aE\3\2\2\2\u036b\u0369\3\2\2\2\u036c\u036d\b$\1\2\u036d\u036e"+
"\5D#\2\u036e\u0377\3\2\2\2\u036f\u0370\f\4\2\2\u0370\u0371\7m\2\2\u0371"+
"\u0376\5D#\2\u0372\u0373\f\3\2\2\u0373\u0374\7n\2\2\u0374\u0376\5D#\2"+
"\u0375\u036f\3\2\2\2\u0375\u0372\3\2\2\2\u0376\u0379\3\2\2\2\u0377\u0375"+
"\3\2\2\2\u0377\u0378\3\2\2\2\u0378G\3\2\2\2\u0379\u0377\3\2\2\2\u037a"+
"\u037b\b%\1\2\u037b\u037c\5F$\2\u037c\u0382\3\2\2\2\u037d\u037e\f\3\2"+
"\2\u037e\u037f\7\\\2\2\u037f\u0381\5F$\2\u0380\u037d\3\2\2\2\u0381\u0384"+
"\3\2\2\2\u0382\u0380\3\2\2\2\u0382\u0383\3\2\2\2\u0383I\3\2\2\2\u0384"+
"\u0382\3\2\2\2\u0385\u0386\b&\1\2\u0386\u0387\5H%\2\u0387\u038d\3\2\2"+
"\2\u0388\u0389\f\3\2\2\u0389\u038a\7[\2\2\u038a\u038c\5H%\2\u038b\u0388"+
"\3\2\2\2\u038c\u038f\3\2\2\2\u038d\u038b\3\2\2\2\u038d\u038e\3\2\2\2\u038e"+
"K\3\2\2\2\u038f\u038d\3\2\2\2\u0390\u0391\b\'\1\2\u0391\u0392\5J&\2\u0392"+
"\u0398\3\2\2\2\u0393\u0394\f\3\2\2\u0394\u0395\7]\2\2\u0395\u0397\5J&"+
"\2\u0396\u0393\3\2\2\2\u0397\u039a\3\2\2\2\u0398\u0396\3\2\2\2\u0398\u0399"+
"\3\2\2\2\u0399M\3\2\2\2\u039a\u0398\3\2\2\2\u039b\u039c\b(\1\2\u039c\u039d"+
"\5L\'\2\u039d\u03a3\3\2\2\2\u039e\u039f\f\3\2\2\u039f\u03a0\7q\2\2\u03a0"+
"\u03a2\5L\'\2\u03a1\u039e\3\2\2\2\u03a2\u03a5\3\2\2\2\u03a3\u03a1\3\2"+
"\2\2\u03a3\u03a4\3\2\2\2\u03a4O\3\2\2\2\u03a5\u03a3\3\2\2\2\u03a6\u03a7"+
"\b)\1\2\u03a7\u03a8\5N(\2\u03a8\u03ae\3\2\2\2\u03a9\u03aa\f\3\2\2\u03aa"+
"\u03ab\7r\2\2\u03ab\u03ad\5N(\2\u03ac\u03a9\3\2\2\2\u03ad\u03b0\3\2\2"+
"\2\u03ae\u03ac\3\2\2\2\u03ae\u03af\3\2\2\2\u03afQ\3\2\2\2\u03b0\u03ae"+
"\3\2\2\2\u03b1\u03b9\5P)\2\u03b2\u03b3\5P)\2\u03b3\u03b4\7x\2\2\u03b4"+
"\u03b5\5X-\2\u03b5\u03b6\7y\2\2\u03b6\u03b7\5T+\2\u03b7\u03b9\3\2\2\2"+
"\u03b8\u03b1\3\2\2\2\u03b8\u03b2\3\2\2\2\u03b9S\3\2\2\2\u03ba\u03c1\5"+
"R*\2\u03bb\u03bc\5P)\2\u03bc\u03bd\5V,\2\u03bd\u03be\5\u0118\u008d\2\u03be"+
"\u03c1\3\2\2\2\u03bf\u03c1\5\u0178\u00bd\2\u03c0\u03ba\3\2\2\2\u03c0\u03bb"+
"\3\2\2\2\u03c0\u03bf\3\2\2\2\u03c1U\3\2\2\2\u03c2\u03ce\7`\2\2\u03c3\u03ce"+
"\7e\2\2\u03c4\u03ce\7f\2\2\u03c5\u03ce\7g\2\2\u03c6\u03ce\7c\2\2\u03c7"+
"\u03ce\7d\2\2\u03c8\u03ce\5\u0184\u00c3\2\u03c9\u03ce\7l\2\2\u03ca\u03ce"+
"\7i\2\2\u03cb\u03ce\7h\2\2\u03cc\u03ce\7j\2\2\u03cd\u03c2\3\2\2\2\u03cd"+
"\u03c3\3\2\2\2\u03cd\u03c4\3\2\2\2\u03cd\u03c5\3\2\2\2\u03cd\u03c6\3\2"+
"\2\2\u03cd\u03c7\3\2\2\2\u03cd\u03c8\3\2\2\2\u03cd\u03c9\3\2\2\2\u03cd"+
"\u03ca\3\2\2\2\u03cd\u03cb\3\2\2\2\u03cd\u03cc\3\2\2\2\u03ceW\3\2\2\2"+
"\u03cf\u03d0\b-\1\2\u03d0\u03d1\5T+\2\u03d1\u03d7\3\2\2\2\u03d2\u03d3"+
"\f\3\2\2\u03d3\u03d4\7u\2\2\u03d4\u03d6\5T+\2\u03d5\u03d2\3\2\2\2\u03d6"+
"\u03d9\3\2\2\2\u03d7\u03d5\3\2\2\2\u03d7\u03d8\3\2\2\2\u03d8Y\3\2\2\2"+
"\u03d9\u03d7\3\2\2\2\u03da\u03db\5R*\2\u03db[\3\2\2\2\u03dc\u03f7\5^\60"+
"\2\u03dd\u03df\5\u00d0i\2\u03de\u03dd\3\2\2\2\u03de\u03df\3\2\2\2\u03df"+
"\u03e0\3\2\2\2\u03e0\u03f7\5`\61\2\u03e1\u03e3\5\u00d0i\2\u03e2\u03e1"+
"\3\2\2\2\u03e2\u03e3\3\2\2\2\u03e3\u03e4\3\2\2\2\u03e4\u03f7\5b\62\2\u03e5"+
"\u03e7\5\u00d0i\2\u03e6\u03e5\3\2\2\2\u03e6\u03e7\3\2\2\2\u03e7\u03e8"+
"\3\2\2\2\u03e8\u03f7\5f\64\2\u03e9\u03eb\5\u00d0i\2\u03ea\u03e9\3\2\2"+
"\2\u03ea\u03eb\3\2\2\2\u03eb\u03ec\3\2\2\2\u03ec\u03f7\5j\66\2\u03ed\u03ef"+
"\5\u00d0i\2\u03ee\u03ed\3\2\2\2\u03ee\u03ef\3\2\2\2\u03ef\u03f0\3\2\2"+
"\2\u03f0\u03f7\5r:\2\u03f1\u03f7\5t;\2\u03f2\u03f4\5\u00d0i\2\u03f3\u03f2"+
"\3\2\2\2\u03f3\u03f4\3\2\2\2\u03f4\u03f5\3\2\2\2\u03f5\u03f7\5\u016e\u00b8"+
"\2\u03f6\u03dc\3\2\2\2\u03f6\u03de\3\2\2\2\u03f6\u03e2\3\2\2\2\u03f6\u03e6"+
"\3\2\2\2\u03f6\u03ea\3\2\2\2\u03f6\u03ee\3\2\2\2\u03f6\u03f1\3\2\2\2\u03f6"+
"\u03f3\3\2\2\2\u03f7]\3\2\2\2\u03f8\u03fa\5\u00d0i\2\u03f9\u03f8\3\2\2"+
"\2\u03f9\u03fa\3\2\2\2\u03fa\u03fb\3\2\2\2\u03fb\u03fc\7\177\2\2\u03fc"+
"\u03fd\7y\2\2\u03fd\u040d\5\\/\2\u03fe\u0400\5\u00d0i\2\u03ff\u03fe\3"+
"\2\2\2\u03ff\u0400\3\2\2\2\u0400\u0401\3\2\2\2\u0401\u0402\7\13\2\2\u0402"+
"\u0403\5Z.\2\u0403\u0404\7y\2\2\u0404\u0405\5\\/\2\u0405\u040d\3\2\2\2"+
"\u0406\u0408\5\u00d0i\2\u0407\u0406\3\2\2\2\u0407\u0408\3\2\2\2\u0408"+
"\u0409\3\2\2\2\u0409\u040a\7\26\2\2\u040a\u040b\7y\2\2\u040b\u040d\5\\"+
"/\2\u040c\u03f9\3\2\2\2\u040c\u03ff\3\2\2\2\u040c\u0407\3\2\2\2\u040d"+
"_\3\2\2\2\u040e\u0410\5X-\2\u040f\u040e\3\2\2\2\u040f\u0410\3\2\2\2\u0410"+
"\u0411\3\2\2\2\u0411\u0412\7{\2\2\u0412a\3\2\2\2\u0413\u0415\7T\2\2\u0414"+
"\u0416\5d\63\2\u0415\u0414\3\2\2\2\u0415\u0416\3\2\2\2\u0416\u0417\3\2"+
"\2\2\u0417\u0418\7U\2\2\u0418c\3\2\2\2\u0419\u041a\b\63\1\2\u041a\u041b"+
"\5\\/\2\u041b\u0420\3\2\2\2\u041c\u041d\f\3\2\2\u041d\u041f\5\\/\2\u041e"+
"\u041c\3\2\2\2\u041f\u0422\3\2\2\2\u0420\u041e\3\2\2\2\u0420\u0421\3\2"+
"\2\2\u0421e\3\2\2\2\u0422\u0420\3\2\2\2\u0423\u0424\7&\2\2\u0424\u0425"+
"\7P\2\2\u0425\u0426\5h\65\2\u0426\u0427\7Q\2\2\u0427\u0428\5\\/\2\u0428"+
"\u0438\3\2\2\2\u0429\u042a\7&\2\2\u042a\u042b\7P\2\2\u042b\u042c\5h\65"+
"\2\u042c\u042d\7Q\2\2\u042d\u042e\5\\/\2\u042e\u042f\7\33\2\2\u042f\u0430"+
"\5\\/\2\u0430\u0438\3\2\2\2\u0431\u0432\7>\2\2\u0432\u0433\7P\2\2\u0433"+
"\u0434\5h\65\2\u0434\u0435\7Q\2\2\u0435\u0436\5\\/\2\u0436\u0438\3\2\2"+
"\2\u0437\u0423\3\2\2\2\u0437\u0429\3\2\2\2\u0437\u0431\3\2\2\2\u0438g"+
"\3\2\2\2\u0439\u044a\5X-\2\u043a\u043c\5\u00d0i\2\u043b\u043a\3\2\2\2"+
"\u043b\u043c\3\2\2\2\u043c\u043d\3\2\2\2\u043d\u043e\5\u0088E\2\u043e"+
"\u043f\5\u00eav\2\u043f\u0440\7`\2\2\u0440\u0441\5\u0118\u008d\2\u0441"+
"\u044a\3\2\2\2\u0442\u0444\5\u00d0i\2\u0443\u0442\3\2\2\2\u0443\u0444"+
"\3\2\2\2\u0444\u0445\3\2\2\2\u0445\u0446\5\u0088E\2\u0446\u0447\5\u00ea"+
"v\2\u0447\u0448\5\u011c\u008f\2\u0448\u044a\3\2\2\2\u0449\u0439\3\2\2"+
"\2\u0449\u043b\3\2\2\2\u0449\u0443\3\2\2\2\u044ai\3\2\2\2\u044b\u044c"+
"\7O\2\2\u044c\u044d\7P\2\2\u044d\u044e\5h\65\2\u044e\u044f\7Q\2\2\u044f"+
"\u0450\5\\/\2\u0450\u046f\3\2\2\2\u0451\u0452\7\30\2\2\u0452\u0453\5\\"+
"/\2\u0453\u0454\7O\2\2\u0454\u0455\7P\2\2\u0455\u0456\5X-\2\u0456\u0457"+
"\7Q\2\2\u0457\u0458\7{\2\2\u0458\u046f\3\2\2\2\u0459\u045a\7#\2\2\u045a"+
"\u045b\7P\2\2\u045b\u045d\5l\67\2\u045c\u045e\5h\65\2\u045d\u045c\3\2"+
"\2\2\u045d\u045e\3\2\2\2\u045e\u045f\3\2\2\2\u045f\u0461\7{\2\2\u0460"+
"\u0462\5X-\2\u0461\u0460\3\2\2\2\u0461\u0462\3\2\2\2\u0462\u0463\3\2\2"+
"\2\u0463\u0464\7Q\2\2\u0464\u0465\5\\/\2\u0465\u046f\3\2\2\2\u0466\u0467"+
"\7#\2\2\u0467\u0468\7P\2\2\u0468\u0469\5n8\2\u0469\u046a\7y\2\2\u046a"+
"\u046b\5p9\2\u046b\u046c\7Q\2\2\u046c\u046d\5\\/\2\u046d\u046f\3\2\2\2"+
"\u046e\u044b\3\2\2\2\u046e\u0451\3\2\2\2\u046e\u0459\3\2\2\2\u046e\u0466"+
"\3\2\2\2\u046fk\3\2\2\2\u0470\u0473\5`\61\2\u0471\u0473\5~@\2\u0472\u0470"+
"\3\2\2\2\u0472\u0471\3\2\2\2\u0473m\3\2\2\2\u0474\u0476\5\u00d0i\2\u0475"+
"\u0474\3\2\2\2\u0475\u0476\3\2\2\2\u0476\u0477\3\2\2\2\u0477\u0478\5\u0088"+
"E\2\u0478\u0479\5\u00eav\2\u0479o\3\2\2\2\u047a\u047d\5X-\2\u047b\u047d"+
"\5\u011c\u008f\2\u047c\u047a\3\2\2\2\u047c\u047b\3\2\2\2\u047dq\3\2\2"+
"\2\u047e\u047f\7\n\2\2\u047f\u048f\7{\2\2\u0480\u0481\7\24\2\2\u0481\u048f"+
"\7{\2\2\u0482\u0484\7\66\2\2\u0483\u0485\5X-\2\u0484\u0483\3\2\2\2\u0484"+
"\u0485\3\2\2\2\u0485\u0486\3\2\2\2\u0486\u048f\7{\2\2\u0487\u0488\7\66"+
"\2\2\u0488\u0489\5\u011c\u008f\2\u0489\u048a\7{\2\2\u048a\u048f\3\2\2"+
"\2\u048b\u048c\7%\2\2\u048c\u048d\7\177\2\2\u048d\u048f\7{\2\2\u048e\u047e"+
"\3\2\2\2\u048e\u0480\3\2\2\2\u048e\u0482\3\2\2\2\u048e\u0487\3\2\2\2\u048e"+
"\u048b\3\2\2\2\u048fs\3\2\2\2\u0490\u0491\5z>\2\u0491u\3\2\2\2\u0492\u0493"+
"\b<\1\2\u0493\u0494\5x=\2\u0494\u0499\3\2\2\2\u0495\u0496\f\3\2\2\u0496"+
"\u0498\5x=\2\u0497\u0495\3\2\2\2\u0498\u049b\3\2\2\2\u0499\u0497\3\2\2"+
"\2\u0499\u049a\3\2\2\2\u049aw\3\2\2\2\u049b\u0499\3\2\2\2\u049c\u04a6"+
"\5z>\2\u049d\u04a6\5\u0110\u0089\2\u049e\u04a6\5\u0156\u00ac\2\u049f\u04a6"+
"\5\u016a\u00b6\2\u04a0\u04a6\5\u016c\u00b7\2\u04a1\u04a6\5\u00ceh\2\u04a2"+
"\u04a6\5\u00b6\\\2\u04a3\u04a6\5\u0082B\2\u04a4\u04a6\5\u0084C\2\u04a5"+
"\u049c\3\2\2\2\u04a5\u049d\3\2\2\2\u04a5\u049e\3\2\2\2\u04a5\u049f\3\2"+
"\2\2\u04a5\u04a0\3\2\2\2\u04a5\u04a1\3\2\2\2\u04a5\u04a2\3\2\2\2\u04a5"+
"\u04a3\3\2\2\2\u04a5\u04a4\3\2\2\2\u04a6y\3\2\2\2\u04a7\u04b0\5~@\2\u04a8"+
"\u04b0\5\u00ccg\2\u04a9\u04b0\5\u00c4c\2\u04aa\u04b0\5\u00c8e\2\u04ab"+
"\u04b0\5\u00caf\2\u04ac\u04b0\5\u0080A\2\u04ad\u04b0\5|?\2\u04ae\u04b0"+
"\5\u00a6T\2\u04af\u04a7\3\2\2\2\u04af\u04a8\3\2\2\2\u04af\u04a9\3\2\2"+
"\2\u04af\u04aa\3\2\2\2\u04af\u04ab\3\2\2\2\u04af\u04ac\3\2\2\2\u04af\u04ad"+
"\3\2\2\2\u04af\u04ae\3\2\2\2\u04b0{\3\2\2\2\u04b1\u04b2\7J\2\2\u04b2\u04b4"+
"\7\177\2\2\u04b3\u04b5\5\u00d0i\2\u04b4\u04b3\3\2\2\2\u04b4\u04b5\3\2"+
"\2\2\u04b5\u04b6\3\2\2\2\u04b6\u04b7\7`\2\2\u04b7\u04b8\5\u00fe\u0080"+
"\2\u04b8\u04b9\7{\2\2\u04b9}\3\2\2\2\u04ba\u04bc\5\u0088E\2\u04bb\u04ba"+
"\3\2\2\2\u04bb\u04bc\3\2\2\2\u04bc\u04be\3\2\2\2\u04bd\u04bf\5\u00e6t"+
"\2\u04be\u04bd\3\2\2\2\u04be\u04bf\3\2\2\2\u04bf\u04c0\3\2\2\2\u04c0\u04c9"+
"\7{\2\2\u04c1\u04c3\5\u00d0i\2\u04c2\u04c4\5\u0088E\2\u04c3\u04c2\3\2"+
"\2\2\u04c3\u04c4\3\2\2\2\u04c4\u04c5\3\2\2\2\u04c5\u04c6\5\u00e6t\2\u04c6"+
"\u04c7\7{\2\2\u04c7\u04c9\3\2\2\2\u04c8\u04bb\3\2\2\2\u04c8\u04c1\3\2"+
"\2\2\u04c9\177\3\2\2\2\u04ca\u04cb\7;\2\2\u04cb\u04cc\7P\2\2\u04cc\u04cd"+
"\5Z.\2\u04cd\u04ce\7u\2\2\u04ce\u04cf\7\u0088\2\2\u04cf\u04d0\7Q\2\2\u04d0"+
"\u04d1\7{\2\2\u04d1\u0081\3\2\2\2\u04d2\u04d3\7{\2\2\u04d3\u0083\3\2\2"+
"\2\u04d4\u04d5\5\u00d0i\2\u04d5\u04d6\7{\2\2\u04d6\u0085\3\2\2\2\u04d7"+
"\u04de\5\u008aF\2\u04d8\u04de\5\u0090I\2\u04d9\u04de\5\u008cG\2\u04da"+
"\u04de\7$\2\2\u04db\u04de\7E\2\2\u04dc\u04de\7\22\2\2\u04dd\u04d7\3\2"+
"\2\2\u04dd\u04d8\3\2\2\2\u04dd\u04d9\3\2\2\2\u04dd\u04da\3\2\2\2\u04dd"+
"\u04db\3\2\2\2\u04dd\u04dc\3\2\2\2\u04de\u0087\3\2\2\2\u04df\u04e1\5\u0086"+
"D\2\u04e0\u04e2\5\u00d0i\2\u04e1\u04e0\3\2\2\2\u04e1\u04e2\3\2\2\2\u04e2"+
"\u04e7\3\2\2\2\u04e3\u04e4\5\u0086D\2\u04e4\u04e5\5\u0088E\2\u04e5\u04e7"+
"\3\2\2\2\u04e6\u04df\3\2\2\2\u04e6\u04e3\3\2\2\2\u04e7\u0089\3\2\2\2\u04e8"+
"\u04e9\t\4\2\2\u04e9\u008b\3\2\2\2\u04ea\u04eb\t\5\2\2\u04eb\u008d\3\2"+
"\2\2\u04ec\u04ed\7\177\2\2\u04ed\u008f\3\2\2\2\u04ee\u04f2\5\u0092J\2"+
"\u04ef\u04f2\5\u0120\u0091\2\u04f0\u04f2\5\u00a2R\2\u04f1\u04ee\3\2\2"+
"\2\u04f1\u04ef\3\2\2\2\u04f1\u04f0\3\2\2\2\u04f2\u0091\3\2\2\2\u04f3\u04f8"+
"\5\u0098M\2\u04f4\u04f8\5\u009eP\2\u04f5\u04f8\5\u0168\u00b5\2\u04f6\u04f8"+
"\5\u00f8}\2\u04f7\u04f3\3\2\2\2\u04f7\u04f4\3\2\2\2\u04f7\u04f5\3\2\2"+
"\2\u04f7\u04f6\3\2\2\2\u04f8\u0093\3\2\2\2\u04f9\u04fb\5\u0090I\2\u04fa"+
"\u04fc\5\u00d0i\2\u04fb\u04fa\3\2\2\2\u04fb\u04fc\3\2\2\2\u04fc\u0501"+
"\3\2\2\2\u04fd\u04fe\5\u0090I\2\u04fe\u04ff\5\u0094K\2\u04ff\u0501\3\2"+
"\2\2\u0500\u04f9\3\2\2\2\u0500\u04fd\3\2\2\2\u0501\u0095\3\2\2\2\u0502"+
"\u0504\5\u0092J\2\u0503\u0505\5\u00d0i\2\u0504\u0503\3\2\2\2\u0504\u0505"+
"\3\2\2\2\u0505\u050a\3\2\2\2\u0506\u0507\5\u0092J\2\u0507\u0508\5\u0096"+
"L\2\u0508\u050a\3\2\2\2\u0509\u0502\3\2\2\2\u0509\u0506\3\2\2\2\u050a"+
"\u0097\3\2\2\2\u050b\u050d\5\f\7\2\u050c\u050b\3\2\2\2\u050c\u050d\3\2"+
"\2\2\u050d\u050e\3\2\2\2\u050e\u0523\5\u009aN\2\u050f\u0510\5\f\7\2\u0510"+
"\u0511\7?\2\2\u0511\u0512\5\u015e\u00b0\2\u0512\u0523\3\2\2\2\u0513\u0523"+
"\7\r\2\2\u0514\u0523\7\16\2\2\u0515\u0523\7\17\2\2\u0516\u0523\7N\2\2"+
"\u0517\u0523\7\t\2\2\u0518\u0523\7\67\2\2\u0519\u0523\7(\2\2\u051a\u0523"+
"\7)\2\2\u051b\u0523\78\2\2\u051c\u0523\7I\2\2\u051d\u0523\7\"\2\2\u051e"+
"\u0523\7\31\2\2\u051f\u0523\7L\2\2\u0520\u0523\7\b\2\2\u0521\u0523\5\u009c"+
"O\2\u0522\u050c\3\2\2\2\u0522\u050f\3\2\2\2\u0522\u0513\3\2\2\2\u0522"+
"\u0514\3\2\2\2\u0522\u0515\3\2\2\2\u0522\u0516\3\2\2\2\u0522\u0517\3\2"+
"\2\2\u0522\u0518\3\2\2\2\u0522\u0519\3\2\2\2\u0522\u051a\3\2\2\2\u0522"+
"\u051b\3\2\2\2\u0522\u051c\3\2\2\2\u0522\u051d\3\2\2\2\u0522\u051e\3\2"+
"\2\2\u0522\u051f\3\2\2\2\u0522\u0520\3\2\2\2\u0522\u0521\3\2\2\2\u0523"+
"\u0099\3\2\2\2\u0524\u0529\5\u011e\u0090\2\u0525\u0529\5\u00a0Q\2\u0526"+
"\u0529\5\u008eH\2\u0527\u0529\5\u015e\u00b0\2\u0528\u0524\3\2\2\2\u0528"+
"\u0525\3\2\2\2\u0528\u0526\3\2\2\2\u0528\u0527\3\2\2\2\u0529\u009b\3\2"+
"\2\2\u052a\u052b\7\25\2\2\u052b\u052c\7P\2\2\u052c\u052d\5X-\2\u052d\u052e"+
"\7Q\2\2\u052e\u0534\3\2\2\2\u052f\u0530\7\25\2\2\u0530\u0531\7P\2\2\u0531"+
"\u0532\7\b\2\2\u0532\u0534\7Q\2\2\u0533\u052a\3\2\2\2\u0533\u052f\3\2"+
"\2\2\u0534\u009d\3\2\2\2\u0535\u0537\5\u0128\u0095\2\u0536\u0538\5\u00d0"+
"i\2\u0537\u0536\3\2\2\2\u0537\u0538\3\2\2\2\u0538\u053a\3\2\2\2\u0539"+
"\u053b\5\f\7\2\u053a\u0539\3\2\2\2\u053a\u053b\3\2\2\2\u053b\u053c\3\2"+
"\2\2\u053c\u053d\7\177\2\2\u053d\u054e\3\2\2\2\u053e\u053f\5\u0128\u0095"+
"\2\u053f\u0540\5\u015e\u00b0\2\u0540\u054e\3\2\2\2\u0541\u0542\5\u0128"+
"\u0095\2\u0542\u0544\5\f\7\2\u0543\u0545\7?\2\2\u0544\u0543\3\2\2\2\u0544"+
"\u0545\3\2\2\2\u0545\u0546\3\2\2\2\u0546\u0547\5\u015e\u00b0\2\u0547\u054e"+
"\3\2\2\2\u0548\u054a\7\34\2\2\u0549\u054b\5\f\7\2\u054a\u0549\3\2\2\2"+
"\u054a\u054b\3\2\2\2\u054b\u054c\3\2\2\2\u054c\u054e\7\177\2\2\u054d\u0535"+
"\3\2\2\2\u054d\u053e\3\2\2\2\u054d\u0541\3\2\2\2\u054d\u0548\3\2\2\2\u054e"+
"\u009f\3\2\2\2\u054f\u0550\7\177\2\2\u0550\u00a1\3\2\2\2\u0551\u0552\5"+
"\u00a4S\2\u0552\u0554\7T\2\2\u0553\u0555\5\u00acW\2\u0554\u0553\3\2\2"+
"\2\u0554\u0555\3\2\2\2\u0555\u0556\3\2\2\2\u0556\u0557\7U\2\2\u0557\u055f"+
"\3\2\2\2\u0558\u0559\5\u00a4S\2\u0559\u055a\7T\2\2\u055a\u055b\5\u00ac"+
"W\2\u055b\u055c\7u\2\2\u055c\u055d\7U\2\2\u055d\u055f\3\2\2\2\u055e\u0551"+
"\3\2\2\2\u055e\u0558\3\2\2\2\u055f\u00a3\3\2\2\2\u0560\u0562\5\u00a8U"+
"\2\u0561\u0563\5\u00d0i\2\u0562\u0561\3\2\2\2\u0562\u0563\3\2\2\2\u0563"+
"\u0565\3\2\2\2\u0564\u0566\7\177\2\2\u0565\u0564\3\2\2\2\u0565\u0566\3"+
"\2\2\2\u0566\u0568\3\2\2\2\u0567\u0569\5\u00aaV\2\u0568\u0567\3\2\2\2"+
"\u0568\u0569\3\2\2\2\u0569\u0574\3\2\2\2\u056a\u056c\5\u00a8U\2\u056b"+
"\u056d\5\u00d0i\2\u056c\u056b\3\2\2\2\u056c\u056d\3\2\2\2\u056d\u056e"+
"\3\2\2\2\u056e\u056f\5\f\7\2\u056f\u0571\7\177\2\2\u0570\u0572\5\u00aa"+
"V\2\u0571\u0570\3\2\2\2\u0571\u0572\3\2\2\2\u0572\u0574\3\2\2\2\u0573"+
"\u0560\3\2\2\2\u0573\u056a\3\2\2\2\u0574\u00a5\3\2\2\2\u0575\u0577\5\u00a8"+
"U\2\u0576\u0578\5\u00d0i\2\u0577\u0576\3\2\2\2\u0577\u0578\3\2\2\2\u0578"+
"\u0579\3\2\2\2\u0579\u057b\7\177\2\2\u057a\u057c\5\u00aaV\2\u057b\u057a"+
"\3\2\2\2\u057b\u057c\3\2\2\2\u057c\u057d\3\2\2\2\u057d\u057e\7{\2\2\u057e"+
"\u00a7\3\2\2\2\u057f\u0585\7\34\2\2\u0580\u0581\7\34\2\2\u0581\u0585\7"+
"\20\2\2\u0582\u0583\7\34\2\2\u0583\u0585\7=\2\2\u0584\u057f\3\2\2\2\u0584"+
"\u0580\3\2\2\2\u0584\u0582\3\2\2\2\u0585\u00a9\3\2\2\2\u0586\u0587\7y"+
"\2\2\u0587\u0588\5\u0094K\2\u0588\u00ab\3\2\2\2\u0589\u058a\bW\1\2\u058a"+
"\u058b\5\u00aeX\2\u058b\u0591\3\2\2\2\u058c\u058d\f\3\2\2\u058d\u058e"+
"\7u\2\2\u058e\u0590\5\u00aeX\2\u058f\u058c\3\2\2\2\u0590\u0593\3\2\2\2"+
"\u0591\u058f\3\2\2\2\u0591\u0592\3\2\2\2\u0592\u00ad\3\2\2\2\u0593\u0591"+
"\3\2\2\2\u0594\u059a\5\u00b0Y\2\u0595\u0596\5\u00b0Y\2\u0596\u0597\7`"+
"\2\2\u0597\u0598\5Z.\2\u0598\u059a\3\2\2\2\u0599\u0594\3\2\2\2\u0599\u0595"+
"\3\2\2\2\u059a\u00af\3\2\2\2\u059b\u059c\7\177\2\2\u059c\u00b1\3\2\2\2"+
"\u059d\u05a0\5\u00b4[\2\u059e\u05a0\5\u00c2b\2\u059f\u059d\3\2\2\2\u059f"+
"\u059e\3\2\2\2\u05a0\u00b3\3\2\2\2\u05a1\u05a2\7\177\2\2\u05a2\u00b5\3"+
"\2\2\2\u05a3\u05a6\5\u00b8]\2\u05a4\u05a6\5\u00be`\2\u05a5\u05a3\3\2\2"+
"\2\u05a5\u05a4\3\2\2\2\u05a6\u00b7\3\2\2\2\u05a7\u05aa\5\u00ba^\2\u05a8"+
"\u05aa\5\u00bc_\2\u05a9\u05a7\3\2\2\2\u05a9\u05a8\3\2\2\2\u05aa\u00b9"+
"\3\2\2\2\u05ab\u05ad\7\'\2\2\u05ac\u05ab\3\2\2\2\u05ac\u05ad\3\2\2\2\u05ad"+
"\u05ae\3\2\2\2\u05ae\u05af\7+\2\2\u05af\u05b0\7\177\2\2\u05b0\u05b1\7"+
"T\2\2\u05b1\u05b2\5\u00c0a\2\u05b2\u05b3\7U\2\2\u05b3\u00bb\3\2\2\2\u05b4"+
"\u05b6\7\'\2\2\u05b5\u05b4\3\2\2\2\u05b5\u05b6\3\2\2\2\u05b6\u05b7\3\2"+
"\2\2\u05b7\u05b8\7+\2\2\u05b8\u05b9\5\u00b4[\2\u05b9\u05ba\7T\2\2\u05ba"+
"\u05bb\5\u00c0a\2\u05bb\u05bc\7U\2\2\u05bc\u00bd\3\2\2\2\u05bd\u05bf\7"+
"\'\2\2\u05be\u05bd\3\2\2\2\u05be\u05bf\3\2\2\2\u05bf\u05c0\3\2\2\2\u05c0"+
"\u05c1\7+\2\2\u05c1\u05c2\7T\2\2\u05c2\u05c3\5\u00c0a\2\u05c3\u05c4\7"+
"U\2\2\u05c4\u00bf\3\2\2\2\u05c5\u05c7\5v<\2\u05c6\u05c5\3\2\2\2\u05c6"+
"\u05c7\3\2\2\2\u05c7\u00c1\3\2\2\2\u05c8\u05c9\7\177\2\2\u05c9\u00c3\3"+
"\2\2\2\u05ca\u05cb\7+\2\2\u05cb\u05cc\7\177\2\2\u05cc\u05cd\7`\2\2\u05cd"+
"\u05ce\5\u00c6d\2\u05ce\u05cf\7{\2\2\u05cf\u00c5\3\2\2\2\u05d0\u05d2\5"+
"\f\7\2\u05d1\u05d0\3\2\2\2\u05d1\u05d2\3\2\2\2\u05d2\u05d3\3\2\2\2\u05d3"+
"\u05d4\5\u00b2Z\2\u05d4\u00c7\3\2\2\2\u05d5\u05d7\7J\2\2\u05d6\u05d8\7"+
"G\2\2\u05d7\u05d6\3\2\2\2\u05d7\u05d8\3\2\2\2\u05d8\u05d9\3\2\2\2\u05d9"+
"\u05da\5\f\7\2\u05da\u05db\5\b\5\2\u05db\u05dc\7{\2\2\u05dc\u05e3\3\2"+
"\2\2\u05dd\u05de\7J\2\2\u05de\u05df\7z\2\2\u05df\u05e0\5\b\5\2\u05e0\u05e1"+
"\7{\2\2\u05e1\u05e3\3\2\2\2\u05e2\u05d5\3\2\2\2\u05e2\u05dd\3\2\2\2\u05e3"+
"\u00c9\3\2\2\2\u05e4\u05e6\5\u00d0i\2\u05e5\u05e4\3\2\2\2\u05e5\u05e6"+
"\3\2\2\2\u05e6\u05e7\3\2\2\2\u05e7\u05e8\7J\2\2\u05e8\u05ea\7+\2\2\u05e9"+
"\u05eb\5\f\7\2\u05ea\u05e9\3\2\2\2\u05ea\u05eb\3\2\2\2\u05eb\u05ec\3\2"+
"\2\2\u05ec\u05ed\5\u00b2Z\2\u05ed\u05ee\7{\2\2\u05ee\u00cb\3\2\2\2\u05ef"+
"\u05f0\7\7\2\2\u05f0\u05f1\7P\2\2\u05f1\u05f2\7\u0088\2\2\u05f2\u05f3"+
"\7Q\2\2\u05f3\u05f4\7{\2\2\u05f4\u00cd\3\2\2\2\u05f5\u05f6\7\37\2\2\u05f6"+
"\u05f7\7\u0088\2\2\u05f7\u05f9\7T\2\2\u05f8\u05fa\5v<\2\u05f9\u05f8\3"+
"\2\2\2\u05f9\u05fa\3\2\2\2\u05fa\u05fb\3\2\2\2\u05fb\u0600\7U\2\2\u05fc"+
"\u05fd\7\37\2\2\u05fd\u05fe\7\u0088\2\2\u05fe\u0600\5x=\2\u05ff\u05f5"+
"\3\2\2\2\u05ff\u05fc\3\2\2\2\u0600\u00cf\3\2\2\2\u0601\u0602\bi\1\2\u0602"+
"\u0603\5\u00d2j\2\u0603\u0608\3\2\2\2\u0604\u0605\f\3\2\2\u0605\u0607"+
"\5\u00d2j\2\u0606\u0604\3\2\2\2\u0607\u060a\3\2\2\2\u0608\u0606\3\2\2"+
"\2\u0608\u0609\3\2\2\2\u0609\u00d1\3\2\2\2\u060a\u0608\3\2\2\2\u060b\u060c"+
"\7R\2\2\u060c\u060d\7R\2\2\u060d\u060e\5\u00d6l\2\u060e\u060f\7S\2\2\u060f"+
"\u0610\7S\2\2\u0610\u0613\3\2\2\2\u0611\u0613\5\u00d4k\2\u0612\u060b\3"+
"\2\2\2\u0612\u0611\3\2\2\2\u0613\u00d3\3\2\2\2\u0614\u0615\7\5\2\2\u0615"+
"\u0616\7P\2\2\u0616\u0618\5\u00fe\u0080\2\u0617\u0619\7~\2\2\u0618\u0617"+
"\3\2\2\2\u0618\u0619\3\2\2\2\u0619\u061a\3\2\2\2\u061a\u061b\7Q\2\2\u061b"+
"\u0625\3\2\2\2\u061c\u061d\7\5\2\2\u061d\u061e\7P\2\2\u061e\u0620\5Z."+
"\2\u061f\u0621\7~\2\2\u0620\u061f\3\2\2\2\u0620\u0621\3\2\2\2\u0621\u0622"+
"\3\2\2\2\u0622\u0623\7Q\2\2\u0623\u0625\3\2\2\2\u0624\u0614\3\2\2\2\u0624"+
"\u061c\3\2\2\2\u0625\u00d5\3\2\2\2\u0626\u0628\bl\1\2\u0627\u0629\5\u00d8"+
"m\2\u0628\u0627\3\2\2\2\u0628\u0629\3\2\2\2\u0629\u062e\3\2\2\2\u062a"+
"\u062b\5\u00d8m\2\u062b\u062c\7~\2\2\u062c\u062e\3\2\2\2\u062d\u0626\3"+
"\2\2\2\u062d\u062a\3\2\2\2\u062e\u063b\3\2\2\2\u062f\u0630\f\5\2\2\u0630"+
"\u0632\7u\2\2\u0631\u0633\5\u00d8m\2\u0632\u0631\3\2\2\2\u0632\u0633\3"+
"\2\2\2\u0633\u063a\3\2\2\2\u0634\u0635\f\3\2\2\u0635\u0636\7u\2\2\u0636"+
"\u0637\5\u00d8m\2\u0637\u0638\7~\2\2\u0638\u063a\3\2\2\2\u0639\u062f\3"+
"\2\2\2\u0639\u0634\3\2\2\2\u063a\u063d\3\2\2\2\u063b\u0639\3\2\2\2\u063b"+
"\u063c\3\2\2\2\u063c\u00d7\3\2\2\2\u063d\u063b\3\2\2\2\u063e\u0640\5\u00da"+
"n\2\u063f\u0641\5\u00e0q\2\u0640\u063f\3\2\2\2\u0640\u0641\3\2\2\2\u0641"+
"\u00d9\3\2\2\2\u0642\u0645\7\177\2\2\u0643\u0645\5\u00dco\2\u0644\u0642"+
"\3\2\2\2\u0644\u0643\3\2\2\2\u0645\u00db\3\2\2\2\u0646\u0647\5\u00dep"+
"\2\u0647\u0648\7z\2\2\u0648\u0649\7\177\2\2\u0649\u00dd\3\2\2\2\u064a"+
"\u064b\7\177\2\2\u064b\u00df\3\2\2\2\u064c\u064d\7P\2\2\u064d\u064e\5"+
"\u00e2r\2\u064e\u064f\7Q\2\2\u064f\u00e1\3\2\2\2\u0650\u0652\br\1\2\u0651"+
"\u0653\5\u00e4s\2\u0652\u0651\3\2\2\2\u0652\u0653\3\2\2\2\u0653\u0658"+
"\3\2\2\2\u0654\u0655\f\3\2\2\u0655\u0657\5\u00e4s\2\u0656\u0654\3\2\2"+
"\2\u0657\u065a\3\2\2\2\u0658\u0656\3\2\2\2\u0658\u0659\3\2\2\2\u0659\u00e3"+
"\3\2\2\2\u065a\u0658\3\2\2\2\u065b\u065c\7P\2\2\u065c\u065d\5\u00e2r\2"+
"\u065d\u065e\7Q\2\2\u065e\u0668\3\2\2\2\u065f\u0660\7R\2\2\u0660\u0661"+
"\5\u00e2r\2\u0661\u0662\7S\2\2\u0662\u0668\3\2\2\2\u0663\u0664\7T\2\2"+
"\u0664\u0665\5\u00e2r\2\u0665\u0666\7U\2\2\u0666\u0668\3\2\2\2\u0667\u065b"+
"\3\2\2\2\u0667\u065f\3\2\2\2\u0667\u0663\3\2\2\2\u0668\u00e5\3\2\2\2\u0669"+
"\u066a\bt\1\2\u066a\u066b\5\u00e8u\2\u066b\u0671\3\2\2\2\u066c\u066d\f"+
"\3\2\2\u066d\u066e\7u\2\2\u066e\u0670\5\u00e8u\2\u066f\u066c\3\2\2\2\u0670"+
"\u0673\3\2\2\2\u0671\u066f\3\2\2\2\u0671\u0672\3\2\2\2\u0672\u00e7\3\2"+
"\2\2\u0673\u0671\3\2\2\2\u0674\u0676\5\u00eav\2\u0675\u0677\5\u0114\u008b"+
"\2\u0676\u0675\3\2\2\2\u0676\u0677\3\2\2\2\u0677\u00e9\3\2\2\2\u0678\u067e"+
"\5\u00ecw\2\u0679\u067a\5\u00eex\2\u067a\u067b\5\u00f0y\2\u067b\u067c"+
"\5\u00f2z\2\u067c\u067e\3\2\2\2\u067d\u0678\3\2\2\2\u067d\u0679\3\2\2"+
"\2\u067e\u00eb\3\2\2\2\u067f\u0684\5\u00eex\2\u0680\u0681\5\u00f4{\2\u0681"+
"\u0682\5\u00ecw\2\u0682\u0684\3\2\2\2\u0683\u067f\3\2\2\2\u0683\u0680"+
"\3\2\2\2\u0684\u00ed\3\2\2\2\u0685\u0686\bx\1\2\u0686\u0688\5\u00fc\177"+
"\2\u0687\u0689\5\u00d0i\2\u0688\u0687\3\2\2\2\u0688\u0689\3\2\2\2\u0689"+
"\u068f\3\2\2\2\u068a\u068b\7P\2\2\u068b\u068c\5\u00ecw\2\u068c\u068d\7"+
"Q\2\2\u068d\u068f\3\2\2\2\u068e\u0685\3\2\2\2\u068e\u068a\3\2\2\2\u068f"+
"\u069d\3\2\2\2\u0690\u0691\f\5\2\2\u0691\u069c\5\u00f0y\2\u0692\u0693"+
"\f\4\2\2\u0693\u0695\7R\2\2\u0694\u0696\5Z.\2\u0695\u0694\3\2\2\2\u0695"+
"\u0696\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u0699\7S\2\2\u0698\u069a\5\u00d0"+
"i\2\u0699\u0698\3\2\2\2\u0699\u069a\3\2\2\2\u069a\u069c\3\2\2\2\u069b"+
"\u0690\3\2\2\2\u069b\u0692\3\2\2\2\u069c\u069f\3\2\2\2\u069d\u069b\3\2"+
"\2\2\u069d\u069e\3\2\2\2\u069e\u00ef\3\2\2\2\u069f\u069d\3\2\2\2\u06a0"+
"\u06a1\7P\2\2\u06a1\u06a2\5\u010a\u0086\2\u06a2\u06a4\7Q\2\2\u06a3\u06a5"+
"\5\u00f6|\2\u06a4\u06a3\3\2\2\2\u06a4\u06a5\3\2\2\2\u06a5\u06a7\3\2\2"+
"\2\u06a6\u06a8\5\u00fa~\2\u06a7\u06a6\3\2\2\2\u06a7\u06a8\3\2\2\2\u06a8"+
"\u06aa\3\2\2\2\u06a9\u06ab\5\u017a\u00be\2\u06aa\u06a9\3\2\2\2\u06aa\u06ab"+
"\3\2\2\2\u06ab\u06ad\3\2\2\2\u06ac\u06ae\5\u00d0i\2\u06ad\u06ac\3\2\2"+
"\2\u06ad\u06ae\3\2\2\2\u06ae\u00f1\3\2\2\2\u06af\u06b0\7w\2\2\u06b0\u06b2"+
"\5\u0096L\2\u06b1\u06b3\5\u0100\u0081\2\u06b2\u06b1\3\2\2\2\u06b2\u06b3"+
"\3\2\2\2\u06b3\u00f3\3\2\2\2\u06b4\u06b6\7X\2\2\u06b5\u06b7\5\u00d0i\2"+
"\u06b6\u06b5\3\2\2\2\u06b6\u06b7\3\2\2\2\u06b7\u06b9\3\2\2\2\u06b8\u06ba"+
"\5\u00f6|\2\u06b9\u06b8\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba\u06cc\3\2\2"+
"\2\u06bb\u06bd\7\\\2\2\u06bc\u06be\5\u00d0i\2\u06bd\u06bc\3\2\2\2\u06bd"+
"\u06be\3\2\2\2\u06be\u06cc\3\2\2\2\u06bf\u06c1\7q\2\2\u06c0\u06c2\5\u00d0"+
"i\2\u06c1\u06c0\3\2\2\2\u06c1\u06c2\3\2\2\2\u06c2\u06cc\3\2\2\2\u06c3"+
"\u06c4\5\f\7\2\u06c4\u06c6\7X\2\2\u06c5\u06c7\5\u00d0i\2\u06c6\u06c5\3"+
"\2\2\2\u06c6\u06c7\3\2\2\2\u06c7\u06c9\3\2\2\2\u06c8\u06ca\5\u00f6|\2"+
"\u06c9\u06c8\3\2\2\2\u06c9\u06ca\3\2\2\2\u06ca\u06cc\3\2\2\2\u06cb\u06b4"+
"\3\2\2\2\u06cb\u06bb\3\2\2\2\u06cb\u06bf\3\2\2\2\u06cb\u06c3\3\2\2\2\u06cc"+
"\u00f5\3\2\2\2\u06cd\u06cf\5\u00f8}\2\u06ce\u06d0\5\u00f6|\2\u06cf\u06ce"+
"\3\2\2\2\u06cf\u06d0\3\2\2\2\u06d0\u00f7\3\2\2\2\u06d1\u06d2\t\6\2\2\u06d2"+
"\u00f9\3\2\2\2\u06d3\u06d4\t\7\2\2\u06d4\u00fb\3\2\2\2\u06d5\u06d7\7~"+
"\2\2\u06d6\u06d5\3\2\2\2\u06d6\u06d7\3\2\2\2\u06d7\u06d8\3\2\2\2\u06d8"+
"\u06d9\5\6\4\2\u06d9\u00fd\3\2\2\2\u06da\u06dc\5\u0094K\2\u06db\u06dd"+
"\5\u0100\u0081\2\u06dc\u06db\3\2\2\2\u06dc\u06dd\3\2\2\2\u06dd\u00ff\3"+
"\2\2\2\u06de\u06e7\5\u0102\u0082\2\u06df\u06e1\5\u0104\u0083\2\u06e0\u06df"+
"\3\2\2\2\u06e0\u06e1\3\2\2\2\u06e1\u06e2\3\2\2\2\u06e2\u06e3\5\u00f0y"+
"\2\u06e3\u06e4\5\u00f2z\2\u06e4\u06e7\3\2\2\2\u06e5\u06e7\5\u0106\u0084"+
"\2\u06e6\u06de\3\2\2\2\u06e6\u06e0\3\2\2\2\u06e6\u06e5\3\2\2\2\u06e7\u0101"+
"\3\2\2\2\u06e8\u06ee\5\u0104\u0083\2\u06e9\u06eb\5\u00f4{\2\u06ea\u06ec"+
"\5\u0102\u0082\2\u06eb\u06ea\3\2\2\2\u06eb\u06ec\3\2\2\2\u06ec\u06ee\3"+
"\2\2\2\u06ed\u06e8\3\2\2\2\u06ed\u06e9\3\2\2\2\u06ee\u0103\3\2\2\2\u06ef"+
"\u06f0\b\u0083\1\2\u06f0\u06fe\5\u00f0y\2\u06f1\u06f3\7R\2\2\u06f2\u06f4"+
"\5Z.\2\u06f3\u06f2\3\2\2\2\u06f3\u06f4\3\2\2\2\u06f4\u06f5\3\2\2\2\u06f5"+
"\u06f7\7S\2\2\u06f6\u06f8\5\u00d0i\2\u06f7\u06f6\3\2\2\2\u06f7\u06f8\3"+
"\2\2\2\u06f8\u06fe\3\2\2\2\u06f9\u06fa\7P\2\2\u06fa\u06fb\5\u0102\u0082"+
"\2\u06fb\u06fc\7Q\2\2\u06fc\u06fe\3\2\2\2\u06fd\u06ef\3\2\2\2\u06fd\u06f1"+
"\3\2\2\2\u06fd\u06f9\3\2\2\2\u06fe\u070c\3\2\2\2\u06ff\u0700\f\7\2\2\u0700"+
"\u070b\5\u00f0y\2\u0701\u0702\f\5\2\2\u0702\u0704\7R\2\2\u0703\u0705\5"+
"Z.\2\u0704\u0703\3\2\2\2\u0704\u0705\3\2\2\2\u0705\u0706\3\2\2\2\u0706"+
"\u0708\7S\2\2\u0707\u0709\5\u00d0i\2\u0708\u0707\3\2\2\2\u0708\u0709\3"+
"\2\2\2\u0709\u070b\3\2\2\2\u070a\u06ff\3\2\2\2\u070a\u0701\3\2\2\2\u070b"+
"\u070e\3\2\2\2\u070c\u070a\3\2\2\2\u070c\u070d\3\2\2\2\u070d\u0105\3\2"+
"\2\2\u070e\u070c\3\2\2\2\u070f\u0714\5\u0108\u0085\2\u0710\u0711\5\u00f4"+
"{\2\u0711\u0712\5\u0106\u0084\2\u0712\u0714\3\2\2\2\u0713\u070f\3\2\2"+
"\2\u0713\u0710\3\2\2\2\u0714\u0107\3\2\2\2\u0715\u0716\b\u0085\1\2\u0716"+
"\u0717\7~\2\2\u0717\u0725\3\2\2\2\u0718\u0719\f\5\2\2\u0719\u0724\5\u00f0"+
"y\2\u071a\u071b\f\4\2\2\u071b\u071d\7R\2\2\u071c\u071e\5Z.\2\u071d\u071c"+
"\3\2\2\2\u071d\u071e\3\2\2\2\u071e\u071f\3\2\2\2\u071f\u0721\7S\2\2\u0720"+
"\u0722\5\u00d0i\2\u0721\u0720\3\2\2\2\u0721\u0722\3\2\2\2\u0722\u0724"+
"\3\2\2\2\u0723\u0718\3\2\2\2\u0723\u071a\3\2\2\2\u0724\u0727\3\2\2\2\u0725"+
"\u0723\3\2\2\2\u0725\u0726\3\2\2\2\u0726\u0109\3\2\2\2\u0727\u0725\3\2"+
"\2\2\u0728\u072a\5\u010c\u0087\2\u0729\u0728\3\2\2\2\u0729\u072a\3\2\2"+
"\2\u072a\u072c\3\2\2\2\u072b\u072d\7~\2\2\u072c\u072b\3\2\2\2\u072c\u072d"+
"\3\2\2\2\u072d\u0733\3\2\2\2\u072e\u072f\5\u010c\u0087\2\u072f\u0730\7"+
"u\2\2\u0730\u0731\7~\2\2\u0731\u0733\3\2\2\2\u0732\u0729\3\2\2\2\u0732"+
"\u072e\3\2\2\2\u0733\u010b\3\2\2\2\u0734\u0735\b\u0087\1\2\u0735\u0736"+
"\5\u010e\u0088\2\u0736\u073c\3\2\2\2\u0737\u0738\f\3\2\2\u0738\u0739\7"+
"u\2\2\u0739\u073b\5\u010e\u0088\2\u073a\u0737\3\2\2\2\u073b\u073e\3\2"+
"\2\2\u073c\u073a\3\2\2\2\u073c\u073d\3\2\2\2\u073d\u010d\3\2\2\2\u073e"+
"\u073c\3\2\2\2\u073f\u0741\5\u00d0i\2\u0740\u073f\3\2\2\2\u0740\u0741"+
"\3\2\2\2\u0741\u0742\3\2\2\2\u0742\u0743\5\u0088E\2\u0743\u0744\5\u00ea"+
"v\2\u0744\u075f\3\2\2\2\u0745\u0747\5\u00d0i\2\u0746\u0745\3\2\2\2\u0746"+
"\u0747\3\2\2\2\u0747\u0748\3\2\2\2\u0748\u0749\5\u0088E\2\u0749\u074a"+
"\5\u00eav\2\u074a\u074b\7`\2\2\u074b\u074c\5\u0118\u008d\2\u074c\u075f"+
"\3\2\2\2\u074d\u074f\5\u00d0i\2\u074e\u074d\3\2\2\2\u074e\u074f\3\2\2"+
"\2\u074f\u0750\3\2\2\2\u0750\u0752\5\u0088E\2\u0751\u0753\5\u0100\u0081"+
"\2\u0752\u0751\3\2\2\2\u0752\u0753\3\2\2\2\u0753\u075f\3\2\2\2\u0754\u0756"+
"\5\u00d0i\2\u0755\u0754\3\2\2\2\u0755\u0756\3\2\2\2\u0756\u0757\3\2\2"+
"\2\u0757\u0759\5\u0088E\2\u0758\u075a\5\u0100\u0081\2\u0759\u0758\3\2"+
"\2\2\u0759\u075a\3\2\2\2\u075a\u075b\3\2\2\2\u075b\u075c\7`\2\2\u075c"+
"\u075d\5\u0118\u008d\2\u075d\u075f\3\2\2\2\u075e\u0740\3\2\2\2\u075e\u0746"+
"\3\2\2\2\u075e\u074e\3\2\2\2\u075e\u0755\3\2\2\2\u075f\u010f\3\2\2\2\u0760"+
"\u0762\5\u00d0i\2\u0761\u0760\3\2\2\2\u0761\u0762\3\2\2\2\u0762\u0764"+
"\3\2\2\2\u0763\u0765\5\u0088E\2\u0764\u0763\3\2\2\2\u0764\u0765\3\2\2"+
"\2\u0765\u0766\3\2\2\2\u0766\u0768\5\u00eav\2\u0767\u0769\5\u0132\u009a"+
"\2\u0768\u0767\3\2\2\2\u0768\u0769\3\2\2\2\u0769\u076a\3\2\2\2\u076a\u076b"+
"\5\u0112\u008a\2\u076b\u0111\3\2\2\2\u076c\u076e\5\u014a\u00a6\2\u076d"+
"\u076c\3\2\2\2\u076d\u076e\3\2\2\2\u076e\u076f\3\2\2\2\u076f\u0778\5b"+
"\62\2\u0770\u0778\5\u0170\u00b9\2\u0771\u0772\7`\2\2\u0772\u0773\7\26"+
"\2\2\u0773\u0778\7{\2\2\u0774\u0775\7`\2\2\u0775\u0776\7\27\2\2\u0776"+
"\u0778\7{\2\2\u0777\u076d\3\2\2\2\u0777\u0770\3\2\2\2\u0777\u0771\3\2"+
"\2\2\u0777\u0774\3\2\2\2\u0778\u0113\3\2\2\2\u0779\u077f\5\u0116\u008c"+
"\2\u077a\u077b\7P\2\2\u077b\u077c\5\"\22\2\u077c\u077d\7Q\2\2\u077d\u077f"+
"\3\2\2\2\u077e\u0779\3\2\2\2\u077e\u077a\3\2\2\2\u077f\u0115\3\2\2\2\u0780"+
"\u0781\7`\2\2\u0781\u0784\5\u0118\u008d\2\u0782\u0784\5\u011c\u008f\2"+
"\u0783\u0780\3\2\2\2\u0783\u0782\3\2\2\2\u0784\u0117\3\2\2\2\u0785\u0788"+
"\5T+\2\u0786\u0788\5\u011c\u008f\2\u0787\u0785\3\2\2\2\u0787\u0786\3\2"+
"\2\2\u0788\u0119\3\2\2\2\u0789\u078a\b\u008e\1\2\u078a\u078c\5\u0118\u008d"+
"\2\u078b\u078d\7~\2\2\u078c\u078b\3\2\2\2\u078c\u078d\3\2\2\2\u078d\u0796"+
"\3\2\2\2\u078e\u078f\f\3\2\2\u078f\u0790\7u\2\2\u0790\u0792\5\u0118\u008d"+
"\2\u0791\u0793\7~\2\2\u0792\u0791\3\2\2\2\u0792\u0793\3\2\2\2\u0793\u0795"+
"\3\2\2\2\u0794\u078e\3\2\2\2\u0795\u0798\3\2\2\2\u0796\u0794\3\2\2\2\u0796"+
"\u0797\3\2\2\2\u0797\u011b\3\2\2\2\u0798\u0796\3\2\2\2\u0799\u079a\7T"+
"\2\2\u079a\u079c\5\u011a\u008e\2\u079b\u079d\7u\2\2\u079c\u079b\3\2\2"+
"\2\u079c\u079d\3\2\2\2\u079d\u079e\3\2\2\2\u079e\u079f\7U\2\2\u079f\u07a3"+
"\3\2\2\2\u07a0\u07a1\7T\2\2\u07a1\u07a3\7U\2\2\u07a2\u0799\3\2\2\2\u07a2"+
"\u07a0\3\2\2\2\u07a3\u011d\3\2\2\2\u07a4\u07a7\7\177\2\2\u07a5\u07a7\5"+
"\u015e\u00b0\2\u07a6\u07a4\3\2\2\2\u07a6\u07a5\3\2\2\2\u07a7\u011f\3\2"+
"\2\2\u07a8\u07a9\5\u0122\u0092\2\u07a9\u07ab\7T\2\2\u07aa\u07ac\5\u012a"+
"\u0096\2\u07ab\u07aa\3\2\2\2\u07ab\u07ac\3\2\2\2\u07ac\u07ad\3\2\2\2\u07ad"+
"\u07ae\7U\2\2\u07ae\u0121\3\2\2\2\u07af\u07b1\5\u0128\u0095\2\u07b0\u07b2"+
"\5\u00d0i\2\u07b1\u07b0\3\2\2\2\u07b1\u07b2\3\2\2\2\u07b2\u07b3\3\2\2"+
"\2\u07b3\u07b5\5\u0124\u0093\2\u07b4\u07b6\5\u0126\u0094\2\u07b5\u07b4"+
"\3\2\2\2\u07b5\u07b6\3\2\2\2\u07b6\u07b8\3\2\2\2\u07b7\u07b9\5\u0138\u009d"+
"\2\u07b8\u07b7\3\2\2\2\u07b8\u07b9\3\2\2\2\u07b9\u07c2\3\2\2\2\u07ba\u07bc"+
"\5\u0128\u0095\2\u07bb\u07bd\5\u00d0i\2\u07bc\u07bb\3\2\2\2\u07bc\u07bd"+
"\3\2\2\2\u07bd\u07bf\3\2\2\2\u07be\u07c0\5\u0138\u009d\2\u07bf\u07be\3"+
"\2\2\2\u07bf\u07c0\3\2\2\2\u07c0\u07c2\3\2\2\2\u07c1\u07af\3\2\2\2\u07c1"+
"\u07ba\3\2\2\2\u07c2\u0123\3\2\2\2\u07c3\u07c5\5\f\7\2\u07c4\u07c3\3\2"+
"\2\2\u07c4\u07c5\3\2\2\2\u07c5\u07c6\3\2\2\2\u07c6\u07c7\5\u011e\u0090"+
"\2\u07c7\u0125\3\2\2\2\u07c8\u07c9\7!\2\2\u07c9\u0127\3\2\2\2\u07ca\u07cb"+
"\t\b\2\2\u07cb\u0129\3\2\2\2\u07cc\u07ce\5\u012c\u0097\2\u07cd\u07cf\5"+
"\u012a\u0096\2\u07ce\u07cd\3\2\2\2\u07ce\u07cf\3\2\2\2\u07cf\u07d6\3\2"+
"\2\2\u07d0\u07d1\5\u0142\u00a2\2\u07d1\u07d3\7y\2\2\u07d2\u07d4\5\u012a"+
"\u0096\2\u07d3\u07d2\3\2\2\2\u07d3\u07d4\3\2\2\2\u07d4\u07d6\3\2\2\2\u07d5"+
"\u07cc\3\2\2\2\u07d5\u07d0\3\2\2\2\u07d6\u012b\3\2\2\2\u07d7\u07d9\5\u00d0"+
"i\2\u07d8\u07d7\3\2\2\2\u07d8\u07d9\3\2\2\2\u07d9\u07db\3\2\2\2\u07da"+
"\u07dc\5\u0088E\2\u07db\u07da\3\2\2\2\u07db\u07dc\3\2\2\2\u07dc\u07de"+
"\3\2\2\2\u07dd\u07df\5\u012e\u0098\2\u07de\u07dd\3\2\2\2\u07de\u07df\3"+
"\2\2\2\u07df\u07e0\3\2\2\2\u07e0\u07e8\7{\2\2\u07e1\u07e8\5\u0110\u0089"+
"\2\u07e2\u07e8\5\u00c8e\2\u07e3\u07e8\5\u0080A\2\u07e4\u07e8\5\u0156\u00ac"+
"\2\u07e5\u07e8\5|?\2\u07e6\u07e8\5\u0082B\2\u07e7\u07d8\3\2\2\2\u07e7"+
"\u07e1\3\2\2\2\u07e7\u07e2\3\2\2\2\u07e7\u07e3\3\2\2\2\u07e7\u07e4\3\2"+
"\2\2\u07e7\u07e5\3\2\2\2\u07e7\u07e6\3\2\2\2\u07e8\u012d\3\2\2\2\u07e9"+
"\u07ea\b\u0098\1\2\u07ea\u07eb\5\u0130\u0099\2\u07eb\u07f1\3\2\2\2\u07ec"+
"\u07ed\f\3\2\2\u07ed\u07ee\7u\2\2\u07ee\u07f0\5\u0130\u0099\2\u07ef\u07ec"+
"\3\2\2\2\u07f0\u07f3\3\2\2\2\u07f1\u07ef\3\2\2\2\u07f1\u07f2\3\2\2\2\u07f2"+
"\u012f\3\2\2\2\u07f3\u07f1\3\2\2\2\u07f4\u07f6\5\u00eav\2\u07f5\u07f7"+
"\5\u0132\u009a\2\u07f6\u07f5\3\2\2\2\u07f6\u07f7\3\2\2\2\u07f7\u07f9\3"+
"\2\2\2\u07f8\u07fa\5\u0136\u009c\2\u07f9\u07f8\3\2\2\2\u07f9\u07fa\3\2"+
"\2\2\u07fa\u0808\3\2\2\2\u07fb\u07fd\5\u00eav\2\u07fc\u07fe\5\u0116\u008c"+
"\2\u07fd\u07fc\3\2\2\2\u07fd\u07fe\3\2\2\2\u07fe\u0808\3\2\2\2\u07ff\u0801"+
"\7\177\2\2\u0800\u07ff\3\2\2\2\u0800\u0801\3\2\2\2\u0801\u0803\3\2\2\2"+
"\u0802\u0804\5\u00d0i\2\u0803\u0802\3\2\2\2\u0803\u0804\3\2\2\2\u0804"+
"\u0805\3\2\2\2\u0805\u0806\7y\2\2\u0806\u0808\5Z.\2\u0807\u07f4\3\2\2"+
"\2\u0807\u07fb\3\2\2\2\u0807\u0800\3\2\2\2\u0808\u0131\3\2\2\2\u0809\u080a"+
"\b\u009a\1\2\u080a\u080b\5\u0134\u009b\2\u080b\u0810\3\2\2\2\u080c\u080d"+
"\f\3\2\2\u080d\u080f\5\u0134\u009b\2\u080e\u080c\3\2\2\2\u080f\u0812\3"+
"\2\2\2\u0810\u080e\3\2\2\2\u0810\u0811\3\2\2\2\u0811\u0133\3\2\2\2\u0812"+
"\u0810\3\2\2\2\u0813\u0814\t\t\2\2\u0814\u0135\3\2\2\2\u0815\u0816\7`"+
"\2\2\u0816\u0817\7\u0082\2\2\u0817\u0818\b\u009c\1\2\u0818\u0137\3\2\2"+
"\2\u0819\u081a\7y\2\2\u081a\u081b\5\u013a\u009e\2\u081b\u0139\3\2\2\2"+
"\u081c\u081d\b\u009e\1\2\u081d\u081f\5\u013c\u009f\2\u081e\u0820\7~\2"+
"\2\u081f\u081e\3\2\2\2\u081f\u0820\3\2\2\2\u0820\u0829\3\2\2\2\u0821\u0822"+
"\f\3\2\2\u0822\u0823\7u\2\2\u0823\u0825\5\u013c\u009f\2\u0824\u0826\7"+
"~\2\2\u0825\u0824\3\2\2\2\u0825\u0826\3\2\2\2\u0826\u0828\3\2\2\2\u0827"+
"\u0821\3\2\2\2\u0828\u082b\3\2\2\2\u0829\u0827\3\2\2\2\u0829\u082a\3\2"+
"\2\2\u082a\u013b\3\2\2\2\u082b\u0829\3\2\2\2\u082c\u082e\5\u00d0i\2\u082d"+
"\u082c\3\2\2\2\u082d\u082e\3\2\2\2\u082e\u082f\3\2\2\2\u082f\u0842\5\u0140"+
"\u00a1\2\u0830\u0832\5\u00d0i\2\u0831\u0830\3\2\2\2\u0831\u0832\3\2\2"+
"\2\u0832\u0833\3\2\2\2\u0833\u0835\7K\2\2\u0834\u0836\5\u0142\u00a2\2"+
"\u0835\u0834\3\2\2\2\u0835\u0836\3\2\2\2\u0836\u0837\3\2\2\2\u0837\u0842"+
"\5\u0140\u00a1\2\u0838\u083a\5\u00d0i\2\u0839\u0838\3\2\2\2\u0839\u083a"+
"\3\2\2\2\u083a\u083b\3\2\2\2\u083b\u083d\5\u0142\u00a2\2\u083c\u083e\7"+
"K\2\2\u083d\u083c\3\2\2\2\u083d\u083e\3\2\2\2\u083e\u083f\3\2\2\2\u083f"+
"\u0840\5\u0140\u00a1\2\u0840\u0842\3\2\2\2\u0841\u082d\3\2\2\2\u0841\u0831"+
"\3\2\2\2\u0841\u0839\3\2\2\2\u0842\u013d\3\2\2\2\u0843\u0845\5\f\7\2\u0844"+
"\u0843\3\2\2\2\u0844\u0845\3\2\2\2\u0845\u0846\3\2\2\2\u0846\u0849\5\u011e"+
"\u0090\2\u0847\u0849\5\u009cO\2\u0848\u0844\3\2\2\2\u0848\u0847\3\2\2"+
"\2\u0849\u013f\3\2\2\2\u084a\u084b\5\u013e\u00a0\2\u084b\u0141\3\2\2\2"+
"\u084c\u084d\t\n\2\2\u084d\u0143\3\2\2\2\u084e\u084f\7/\2\2\u084f\u0850"+
"\5\u0146\u00a4\2\u0850\u0145\3\2\2\2\u0851\u0853\5\u0094K\2\u0852\u0854"+
"\5\u0148\u00a5\2\u0853\u0852\3\2\2\2\u0853\u0854\3\2\2\2\u0854\u0147\3"+
"\2\2\2\u0855\u0857\5\u00f4{\2\u0856\u0858\5\u0148\u00a5\2\u0857\u0856"+
"\3\2\2\2\u0857\u0858\3\2\2\2\u0858\u0149\3\2\2\2\u0859\u085a\7y\2\2\u085a"+
"\u085b\5\u014c\u00a7\2\u085b\u014b\3\2\2\2\u085c\u085e\5\u014e\u00a8\2"+
"\u085d\u085f\7~\2\2\u085e\u085d\3\2\2\2\u085e\u085f\3\2\2\2\u085f\u0868"+
"\3\2\2\2\u0860\u0862\5\u014e\u00a8\2\u0861\u0863\7~\2\2\u0862\u0861\3"+
"\2\2\2\u0862\u0863\3\2\2\2\u0863\u0864\3\2\2\2\u0864\u0865\7u\2\2\u0865"+
"\u0866\5\u014c\u00a7\2\u0866\u0868\3\2\2\2\u0867\u085c\3\2\2\2\u0867\u0860"+
"\3\2\2\2\u0868\u014d\3\2\2\2\u0869\u086a\5\u0150\u00a9\2\u086a\u086c\7"+
"P\2\2\u086b\u086d\5\"\22\2\u086c\u086b\3\2\2\2\u086c\u086d\3\2\2\2\u086d"+
"\u086e\3\2\2\2\u086e\u086f\7Q\2\2\u086f\u0874\3\2\2\2\u0870\u0871\5\u0150"+
"\u00a9\2\u0871\u0872\5\u011c\u008f\2\u0872\u0874\3\2\2\2\u0873\u0869\3"+
"\2\2\2\u0873\u0870\3\2\2\2\u0874\u014f\3\2\2\2\u0875\u0878\5\u013e\u00a0"+
"\2\u0876\u0878\7\177\2\2\u0877\u0875\3\2\2\2\u0877\u0876\3\2\2\2\u0878"+
"\u0151\3\2\2\2\u0879\u087a\7/\2\2\u087a\u087b\5\u0186\u00c4\2\u087b\u0153"+
"\3\2\2\2\u087c\u087d\7/\2\2\u087d\u087e\7\u0088\2\2\u087e\u0882\7\177"+
"\2\2\u087f\u0880\7/\2\2\u0880\u0882\7\u008b\2\2\u0881\u087c\3\2\2\2\u0881"+
"\u087f\3\2\2\2\u0882\u0155\3\2\2\2\u0883\u0884\7?\2\2\u0884\u0885\7a\2"+
"\2\u0885\u0886\5\u0158\u00ad\2\u0886\u0887\7b\2\2\u0887\u0888\5x=\2\u0888"+
"\u0157\3\2\2\2\u0889\u088a\b\u00ad\1\2\u088a\u088b\5\u015a\u00ae\2\u088b"+
"\u0891\3\2\2\2\u088c\u088d\f\3\2\2\u088d\u088e\7u\2\2\u088e\u0890\5\u015a"+
"\u00ae\2\u088f\u088c\3\2\2\2\u0890\u0893\3\2\2\2\u0891\u088f\3\2\2\2\u0891"+
"\u0892\3\2\2\2\u0892\u0159\3\2\2\2\u0893\u0891\3\2\2\2\u0894\u0897\5\u015c"+
"\u00af\2\u0895\u0897\5\u010e\u0088\2\u0896\u0894\3\2\2\2\u0896\u0895\3"+
"\2\2\2\u0897\u015b\3\2\2\2\u0898\u089a\7\20\2\2\u0899\u089b\7~\2\2\u089a"+
"\u0899\3\2\2\2\u089a\u089b\3\2\2\2\u089b\u089d\3\2\2\2\u089c\u089e\7\177"+
"\2\2\u089d\u089c\3\2\2\2\u089d\u089e\3\2\2\2\u089e\u08c9\3\2\2\2\u089f"+
"\u08a1\7\20\2\2\u08a0\u08a2\7\177\2\2\u08a1\u08a0\3\2\2\2\u08a1\u08a2"+
"\3\2\2\2\u08a2\u08a3\3\2\2\2\u08a3\u08a4\7`\2\2\u08a4\u08c9\5\u00fe\u0080"+
"\2\u08a5\u08a7\7G\2\2\u08a6\u08a8\7~\2\2\u08a7\u08a6\3\2\2\2\u08a7\u08a8"+
"\3\2\2\2\u08a8\u08aa\3\2\2\2\u08a9\u08ab\7\177\2\2\u08aa\u08a9\3\2\2\2"+
"\u08aa\u08ab\3\2\2\2\u08ab\u08c9\3\2\2\2\u08ac\u08ae\7G\2\2\u08ad\u08af"+
"\7\177\2\2\u08ae\u08ad\3\2\2\2\u08ae\u08af\3\2\2\2\u08af\u08b0\3\2\2\2"+
"\u08b0\u08b1\7`\2\2\u08b1\u08c9\5\u00fe\u0080\2\u08b2\u08b3\7?\2\2\u08b3"+
"\u08b4\7a\2\2\u08b4\u08b5\5\u0158\u00ad\2\u08b5\u08b6\7b\2\2\u08b6\u08b8"+
"\7\20\2\2\u08b7\u08b9\7~\2\2\u08b8\u08b7\3\2\2\2\u08b8\u08b9\3\2\2\2\u08b9"+
"\u08bb\3\2\2\2\u08ba\u08bc\7\177\2\2\u08bb\u08ba\3\2\2\2\u08bb\u08bc\3"+
"\2\2\2\u08bc\u08c9\3\2\2\2\u08bd\u08be\7?\2\2\u08be\u08bf\7a\2\2\u08bf"+
"\u08c0\5\u0158\u00ad\2\u08c0\u08c1\7b\2\2\u08c1\u08c3\7\20\2\2\u08c2\u08c4"+
"\7\177\2\2\u08c3\u08c2\3\2\2\2\u08c3\u08c4\3\2\2\2\u08c4\u08c5\3\2\2\2"+
"\u08c5\u08c6\7`\2\2\u08c6\u08c7\5\6\4\2\u08c7\u08c9\3\2\2\2\u08c8\u0898"+
"\3\2\2\2\u08c8\u089f\3\2\2\2\u08c8\u08a5\3\2\2\2\u08c8\u08ac\3\2\2\2\u08c8"+
"\u08b2\3\2\2\2\u08c8\u08bd\3\2\2\2\u08c9\u015d\3\2\2\2\u08ca\u08cb\5\u0162"+
"\u00b2\2\u08cb\u08cd\7a\2\2\u08cc\u08ce\5\u0164\u00b3\2\u08cd\u08cc\3"+
"\2\2\2\u08cd\u08ce\3\2\2\2\u08ce\u08cf\3\2\2\2\u08cf\u08d0\7b\2\2\u08d0"+
"\u015f\3\2\2\2\u08d1\u08e1\5\u015e\u00b0\2\u08d2\u08d3\5\u0152\u00aa\2"+
"\u08d3\u08d5\7a\2\2\u08d4\u08d6\5\u0164\u00b3\2\u08d5\u08d4\3\2\2\2\u08d5"+
"\u08d6\3\2\2\2\u08d6\u08d7\3\2\2\2\u08d7\u08d8\7b\2\2\u08d8\u08e1\3\2"+
"\2\2\u08d9\u08da\5\u0154\u00ab\2\u08da\u08dc\7a\2\2\u08db\u08dd\5\u0164"+
"\u00b3\2\u08dc\u08db\3\2\2\2\u08dc\u08dd\3\2\2\2\u08dd\u08de\3\2\2\2\u08de"+
"\u08df\7b\2\2\u08df\u08e1\3\2\2\2\u08e0\u08d1\3\2\2\2\u08e0\u08d2\3\2"+
"\2\2\u08e0\u08d9\3\2\2\2\u08e1\u0161\3\2\2\2\u08e2\u08e3\7\177\2\2\u08e3"+
"\u0163\3\2\2\2\u08e4\u08e5\b\u00b3\1\2\u08e5\u08e7\5\u0166\u00b4\2\u08e6"+
"\u08e8\7~\2\2\u08e7\u08e6\3\2\2\2\u08e7\u08e8\3\2\2\2\u08e8\u08f1\3\2"+
"\2\2\u08e9\u08ea\f\3\2\2\u08ea\u08eb\7u\2\2\u08eb\u08ed\5\u0166\u00b4"+
"\2\u08ec\u08ee\7~\2\2\u08ed\u08ec\3\2\2\2\u08ed\u08ee\3\2\2\2\u08ee\u08f0"+
"\3\2\2\2\u08ef\u08e9\3\2\2\2\u08f0\u08f3\3\2\2\2\u08f1\u08ef\3\2\2\2\u08f1"+
"\u08f2\3\2\2\2\u08f2\u0165\3\2\2\2\u08f3\u08f1\3\2\2\2\u08f4\u08f8\5\u00fe"+
"\u0080\2\u08f5\u08f8\5Z.\2\u08f6\u08f8\5\6\4\2\u08f7\u08f4\3\2\2\2\u08f7"+
"\u08f5\3\2\2\2\u08f7\u08f6\3\2\2\2\u08f8\u0167\3\2\2\2\u08f9\u08fa\7G"+
"\2\2\u08fa\u08fb\5\f\7\2\u08fb\u08fc\7\177\2\2\u08fc\u0905\3\2\2\2\u08fd"+
"\u08fe\7G\2\2\u08fe\u0900\5\f\7\2\u08ff\u0901\7?\2\2\u0900\u08ff\3\2\2"+
"\2\u0900\u0901\3\2\2\2\u0901\u0902\3\2\2\2\u0902\u0903\5\u015e\u00b0\2"+
"\u0903\u0905\3\2\2\2\u0904\u08f9\3\2\2\2\u0904\u08fd\3\2\2\2\u0905\u0169"+
"\3\2\2\2\u0906\u0908\7\37\2\2\u0907\u0906\3\2\2\2\u0907\u0908\3\2\2\2"+
"\u0908\u0909\3\2\2\2\u0909\u090a\7?\2\2\u090a\u090b\5x=\2\u090b\u016b"+
"\3\2\2\2\u090c\u090d\7?\2\2\u090d\u090e\7a\2\2\u090e\u090f\7b\2\2\u090f"+
"\u0910\5x=\2\u0910\u016d\3\2\2\2\u0911\u0912\7D\2\2\u0912\u0913\5b\62"+
"\2\u0913\u0914\5\u0172\u00ba\2\u0914\u016f\3\2\2\2\u0915\u0917\7D\2\2"+
"\u0916\u0918\5\u014a\u00a6\2\u0917\u0916\3\2\2\2\u0917\u0918\3\2\2\2\u0918"+
"\u0919\3\2\2\2\u0919\u091a\5b\62\2\u091a\u091b\5\u0172\u00ba\2\u091b\u0171"+
"\3\2\2\2\u091c\u091e\5\u0174\u00bb\2\u091d\u091f\5\u0172\u00ba\2\u091e"+
"\u091d\3\2\2\2\u091e\u091f\3\2\2\2\u091f\u0173\3\2\2\2\u0920\u0921\7\f"+
"\2\2\u0921\u0922\7P\2\2\u0922\u0923\5\u0176\u00bc\2\u0923\u0924\7Q\2\2"+
"\u0924\u0925\5b\62\2\u0925\u0175\3\2\2\2\u0926\u0928\5\u00d0i\2\u0927"+
"\u0926\3\2\2\2\u0927\u0928\3\2\2\2\u0928\u0929\3\2\2\2\u0929\u092a\5\u0094"+
"K\2\u092a\u092b\5\u00eav\2\u092b\u0935\3\2\2\2\u092c\u092e\5\u00d0i\2"+
"\u092d\u092c\3\2\2\2\u092d\u092e\3\2\2\2\u092e\u092f\3\2\2\2\u092f\u0931"+
"\5\u0094K\2\u0930\u0932\5\u0100\u0081\2\u0931\u0930\3\2\2\2\u0931\u0932"+
"\3\2\2\2\u0932\u0935\3\2\2\2\u0933\u0935\7~\2\2\u0934\u0927\3\2\2\2\u0934"+
"\u092d\3\2\2\2\u0934\u0933\3\2\2\2\u0935\u0177\3\2\2\2\u0936\u0938\7B"+
"\2\2\u0937\u0939\5T+\2\u0938\u0937\3\2\2\2\u0938\u0939\3\2\2\2\u0939\u0179"+
"\3\2\2\2\u093a\u093d\5\u017c\u00bf\2\u093b\u093d\5\u0180\u00c1\2\u093c"+
"\u093a\3\2\2\2\u093c\u093b\3\2\2\2\u093d\u017b\3\2\2\2\u093e\u093f\7B"+
"\2\2\u093f\u0941\7P\2\2\u0940\u0942\5\u017e\u00c0\2\u0941\u0940\3\2\2"+
"\2\u0941\u0942\3\2\2\2\u0942\u0943\3\2\2\2\u0943\u0944\7Q\2\2\u0944\u017d"+
"\3\2\2\2\u0945\u0946\b\u00c0\1\2\u0946\u0948\5\u00fe\u0080\2\u0947\u0949"+
"\7~\2\2\u0948\u0947\3\2\2\2\u0948\u0949\3\2\2\2\u0949\u0952\3\2\2\2\u094a"+
"\u094b\f\3\2\2\u094b\u094c\7u\2\2\u094c\u094e\5\u00fe\u0080\2\u094d\u094f"+
"\7~\2\2\u094e\u094d\3\2\2\2\u094e\u094f\3\2\2\2\u094f\u0951\3\2\2\2\u0950"+
"\u094a\3\2\2\2\u0951\u0954\3\2\2\2\u0952\u0950\3\2\2\2\u0952\u0953\3\2"+
"\2\2\u0953\u017f\3\2\2\2\u0954\u0952\3\2\2\2\u0955\u0956\7-\2\2\u0956"+
"\u0957\7P\2\2\u0957\u0958\5Z.\2\u0958\u0959\7Q\2\2\u0959\u095c\3\2\2\2"+
"\u095a\u095c\7-\2\2\u095b\u0955\3\2\2\2\u095b\u095a\3\2\2\2\u095c\u0181"+
"\3\2\2\2\u095d\u095e\7b\2\2\u095e\u095f\7b\2\2\u095f\u0183\3\2\2\2\u0960"+
"\u0961\7b\2\2\u0961\u0962\7b\2\2\u0962\u0963\7`\2\2\u0963\u0185\3\2\2"+
"\2\u0964\u0995\7,\2\2\u0965\u0995\7\27\2\2\u0966\u0967\7,\2\2\u0967\u0968"+
"\7R\2\2\u0968\u0995\7S\2\2\u0969\u096a\7\27\2\2\u096a\u096b\7R\2\2\u096b"+
"\u0995\7S\2\2\u096c\u0995\7V\2\2\u096d\u0995\7W\2\2\u096e\u0995\7X\2\2"+
"\u096f\u0995\7Y\2\2\u0970\u0995\7Z\2\2\u0971\u0995\7[\2\2\u0972\u0995"+
"\7\\\2\2\u0973\u0995\7]\2\2\u0974\u0995\7^\2\2\u0975\u0995\7_\2\2\u0976"+
"\u0995\7`\2\2\u0977\u0995\7a\2\2\u0978\u0995\7b\2\2\u0979\u0995\7c\2\2"+
"\u097a\u0995\7d\2\2\u097b\u0995\7e\2\2\u097c\u0995\7f\2\2\u097d\u0995"+
"\7g\2\2\u097e\u0995\7h\2\2\u097f\u0995\7i\2\2\u0980\u0995\7j\2\2\u0981"+
"\u0995\7k\2\2\u0982\u0995\5\u0182\u00c2\2\u0983\u0995\5\u0184\u00c3\2"+
"\u0984\u0995\7l\2\2\u0985\u0995\7m\2\2\u0986\u0995\7n\2\2\u0987\u0995"+
"\7o\2\2\u0988\u0995\7p\2\2\u0989\u0995\7q\2\2\u098a\u0995\7r\2\2\u098b"+
"\u0995\7s\2\2\u098c\u0995\7t\2\2\u098d\u0995\7u\2\2\u098e\u0995\7v\2\2"+
"\u098f\u0995\7w\2\2\u0990\u0991\7P\2\2\u0991\u0995\7Q\2\2\u0992\u0993"+
"\7R\2\2\u0993\u0995\7S\2\2\u0994\u0964\3\2\2\2\u0994\u0965\3\2\2\2\u0994"+
"\u0966\3\2\2\2\u0994\u0969\3\2\2\2\u0994\u096c\3\2\2\2\u0994\u096d\3\2"+
"\2\2\u0994\u096e\3\2\2\2\u0994\u096f\3\2\2\2\u0994\u0970\3\2\2\2\u0994"+
"\u0971\3\2\2\2\u0994\u0972\3\2\2\2\u0994\u0973\3\2\2\2\u0994\u0974\3\2"+
"\2\2\u0994\u0975\3\2\2\2\u0994\u0976\3\2\2\2\u0994";
private static final String _serializedATNSegment1 =
"\u0977\3\2\2\2\u0994\u0978\3\2\2\2\u0994\u0979\3\2\2\2\u0994\u097a\3\2"+
"\2\2\u0994\u097b\3\2\2\2\u0994\u097c\3\2\2\2\u0994\u097d\3\2\2\2\u0994"+
"\u097e\3\2\2\2\u0994\u097f\3\2\2\2\u0994\u0980\3\2\2\2\u0994\u0981\3\2"+
"\2\2\u0994\u0982\3\2\2\2\u0994\u0983\3\2\2\2\u0994\u0984\3\2\2\2\u0994"+
"\u0985\3\2\2\2\u0994\u0986\3\2\2\2\u0994\u0987\3\2\2\2\u0994\u0988\3\2"+
"\2\2\u0994\u0989\3\2\2\2\u0994\u098a\3\2\2\2\u0994\u098b\3\2\2\2\u0994"+
"\u098c\3\2\2\2\u0994\u098d\3\2\2\2\u0994\u098e\3\2\2\2\u0994\u098f\3\2"+
"\2\2\u0994\u0990\3\2\2\2\u0994\u0992\3\2\2\2\u0995\u0187\3\2\2\2\u0996"+
"\u099e\7\u0080\2\2\u0997\u099e\7\u0086\2\2\u0998\u099e\7\u0087\2\2\u0999"+
"\u099e\7\u0088\2\2\u099a\u099e\5\u018a\u00c6\2\u099b\u099e\5\u018c\u00c7"+
"\2\u099c\u099e\5\u018e\u00c8\2\u099d\u0996\3\2\2\2\u099d\u0997\3\2\2\2"+
"\u099d\u0998\3\2\2\2\u099d\u0999\3\2\2\2\u099d\u099a\3\2\2\2\u099d\u099b"+
"\3\2\2\2\u099d\u099c\3\2\2\2\u099e\u0189\3\2\2\2\u099f\u09a0\t\13\2\2"+
"\u09a0\u018b\3\2\2\2\u09a1\u09a2\7.\2\2\u09a2\u018d\3\2\2\2\u09a3\u09a4"+
"\t\f\2\2\u09a4\u018f\3\2\2\2\u013d\u0191\u019d\u01a1\u01ac\u01b0\u01bf"+
"\u01c6\u01cb\u01cd\u01d2\u01d8\u01e2\u01e9\u01ef\u01f3\u01f8\u01fe\u0205"+
"\u020b\u020e\u0211\u0214\u021b\u0222\u0256\u0265\u026b\u0271\u027e\u0280"+
"\u0286\u0295\u029b\u02b9\u02be\u02c2\u02c6\u02c9\u02cd\u02d3\u02d5\u02dd"+
"\u02e1\u02e4\u02eb\u02f2\u02f6\u02fb\u02ff\u0302\u0307\u030d\u031a\u0325"+
"\u0327\u0336\u0338\u0344\u0346\u0353\u0355\u0367\u0369\u0375\u0377\u0382"+
"\u038d\u0398\u03a3\u03ae\u03b8\u03c0\u03cd\u03d7\u03de\u03e2\u03e6\u03ea"+
"\u03ee\u03f3\u03f6\u03f9\u03ff\u0407\u040c\u040f\u0415\u0420\u0437\u043b"+
"\u0443\u0449\u045d\u0461\u046e\u0472\u0475\u047c\u0484\u048e\u0499\u04a5"+
"\u04af\u04b4\u04bb\u04be\u04c3\u04c8\u04dd\u04e1\u04e6\u04f1\u04f7\u04fb"+
"\u0500\u0504\u0509\u050c\u0522\u0528\u0533\u0537\u053a\u0544\u054a\u054d"+
"\u0554\u055e\u0562\u0565\u0568\u056c\u0571\u0573\u0577\u057b\u0584\u0591"+
"\u0599\u059f\u05a5\u05a9\u05ac\u05b5\u05be\u05c6\u05d1\u05d7\u05e2\u05e5"+
"\u05ea\u05f9\u05ff\u0608\u0612\u0618\u0620\u0624\u0628\u062d\u0632\u0639"+
"\u063b\u0640\u0644\u0652\u0658\u0667\u0671\u0676\u067d\u0683\u0688\u068e"+
"\u0695\u0699\u069b\u069d\u06a4\u06a7\u06aa\u06ad\u06b2\u06b6\u06b9\u06bd"+
"\u06c1\u06c6\u06c9\u06cb\u06cf\u06d6\u06dc\u06e0\u06e6\u06eb\u06ed\u06f3"+
"\u06f7\u06fd\u0704\u0708\u070a\u070c\u0713\u071d\u0721\u0723\u0725\u0729"+
"\u072c\u0732\u073c\u0740\u0746\u074e\u0752\u0755\u0759\u075e\u0761\u0764"+
"\u0768\u076d\u0777\u077e\u0783\u0787\u078c\u0792\u0796\u079c\u07a2\u07a6"+
"\u07ab\u07b1\u07b5\u07b8\u07bc\u07bf\u07c1\u07c4\u07ce\u07d3\u07d5\u07d8"+
"\u07db\u07de\u07e7\u07f1\u07f6\u07f9\u07fd\u0800\u0803\u0807\u0810\u081f"+
"\u0825\u0829\u082d\u0831\u0835\u0839\u083d\u0841\u0844\u0848\u0853\u0857"+
"\u085e\u0862\u0867\u086c\u0873\u0877\u0881\u0891\u0896\u089a\u089d\u08a1"+
"\u08a7\u08aa\u08ae\u08b8\u08bb\u08c3\u08c8\u08cd\u08d5\u08dc\u08e0\u08e7"+
"\u08ed\u08f1\u08f7\u0900\u0904\u0907\u0917\u091e\u0927\u092d\u0931\u0934"+
"\u0938\u093c\u0941\u0948\u094e\u0952\u095b\u0994\u099d";
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);
}
}
}
