hu.bme.mit.theta.c.frontend.dsl.gen.CParser Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of theta-c-frontend Show documentation
Show all versions of theta-c-frontend Show documentation
C Frontend subproject in the Theta model checking framework
// Generated from C.g4 by ANTLR 4.9.2
package hu.bme.mit.theta.c.frontend.dsl.gen;
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 CParser extends Parser {
static { RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); }
protected static final DFA[] _decisionToDFA;
protected static final PredictionContextCache _sharedContextCache =
new PredictionContextCache();
public static final int
T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9,
T__9=10, T__10=11, T__11=12, T__12=13, PRETTY_FUNC=14, Extension=15, Auto=16,
Break=17, Case=18, Char=19, Const=20, Continue=21, Default=22, Do=23,
Double=24, Else=25, Enum=26, Extern=27, Float=28, For=29, Goto=30, If=31,
Inline=32, Int=33, Long=34, Register=35, Restrict=36, Return=37, Short=38,
Signed=39, Sizeof=40, Static=41, Struct=42, Switch=43, Typedef=44, Union=45,
Unsigned=46, Void=47, Volatile=48, While=49, Alignas=50, Alignof=51, Atomic=52,
Bool=53, Complex=54, Generic=55, Imaginary=56, Noreturn=57, StaticAssert=58,
ThreadLocal=59, LeftParen=60, RightParen=61, LeftBracket=62, RightBracket=63,
LeftBrace=64, RightBrace=65, Less=66, LessEqual=67, Greater=68, GreaterEqual=69,
LeftShift=70, RightShift=71, Plus=72, PlusPlus=73, Minus=74, MinusMinus=75,
Star=76, Div=77, Mod=78, And=79, Or=80, AndAnd=81, OrOr=82, Caret=83,
Not=84, Tilde=85, Question=86, Colon=87, Semi=88, Comma=89, Assign=90,
StarAssign=91, DivAssign=92, ModAssign=93, PlusAssign=94, MinusAssign=95,
LeftShiftAssign=96, RightShiftAssign=97, AndAssign=98, XorAssign=99, OrAssign=100,
Equal=101, NotEqual=102, Arrow=103, Dot=104, Ellipsis=105, Identifier=106,
Constant=107, DigitSequence=108, StringLiteral=109, ComplexDefine=110,
IncludeDirective=111, AsmBlock=112, LineAfterPreprocessing=113, LineDirective=114,
PragmaDirective=115, Whitespace=116, Newline=117, BlockComment=118, LineComment=119,
WORD=120;
public static final int
RULE_primaryExpression = 0, RULE_postfixExpression = 1, RULE_postfixExpressionAccess = 2,
RULE_postfixExpressionBrackets = 3, RULE_postfixExpressionBraces = 4,
RULE_postfixExpressionMemberAccess = 5, RULE_postfixExpressionPtrMemberAccess = 6,
RULE_postfixExpressionIncrement = 7, RULE_postfixExpressionDecrement = 8,
RULE_argumentExpressionList = 9, RULE_unaryExpression = 10, RULE_unaryExpressionIncrement = 11,
RULE_unaryExpressionDecrement = 12, RULE_unaryExpressionCast = 13, RULE_unaryExpressionSizeOrAlignOf = 14,
RULE_unaryOperator = 15, RULE_castExpression = 16, RULE_multiplicativeExpression = 17,
RULE_additiveExpression = 18, RULE_shiftExpression = 19, RULE_relationalExpression = 20,
RULE_equalityExpression = 21, RULE_andExpression = 22, RULE_exclusiveOrExpression = 23,
RULE_inclusiveOrExpression = 24, RULE_logicalAndExpression = 25, RULE_logicalOrExpression = 26,
RULE_conditionalExpression = 27, RULE_assignmentExpression = 28, RULE_assignmentOperator = 29,
RULE_expression = 30, RULE_constantExpression = 31, RULE_declaration = 32,
RULE_declarationSpecifiers = 33, RULE_declarationSpecifiers2 = 34, RULE_castDeclarationSpecifierList = 35,
RULE_castDeclarationSpecifier = 36, RULE_declarationSpecifier = 37, RULE_initDeclaratorList = 38,
RULE_initDeclarator = 39, RULE_storageClassSpecifier = 40, RULE_typeSpecifier = 41,
RULE_typeSpecifierPointer = 42, RULE_structOrUnionSpecifier = 43, RULE_structOrUnion = 44,
RULE_structDeclarationList = 45, RULE_structDeclaration = 46, RULE_specifierQualifierList = 47,
RULE_typeSpecifierOrQualifier = 48, RULE_structDeclaratorList = 49, RULE_structDeclarator = 50,
RULE_enumSpecifier = 51, RULE_enumeratorList = 52, RULE_enumerator = 53,
RULE_enumerationConstant = 54, RULE_atomicTypeSpecifier = 55, RULE_typeQualifier = 56,
RULE_functionSpecifier = 57, RULE_alignmentSpecifier = 58, RULE_declarator = 59,
RULE_directDeclarator = 60, RULE_gccDeclaratorExtension = 61, RULE_gccAttributeSpecifier = 62,
RULE_gccAttributeList = 63, RULE_gccAttribute = 64, RULE_nestedParenthesesBlock = 65,
RULE_pointer = 66, RULE_typeQualifierList = 67, RULE_parameterTypeList = 68,
RULE_parameterList = 69, RULE_parameterDeclaration = 70, RULE_typeName = 71,
RULE_abstractDeclarator = 72, RULE_directAbstractDeclarator = 73, RULE_typedefName = 74,
RULE_initializer = 75, RULE_initializerList = 76, RULE_designation = 77,
RULE_designatorList = 78, RULE_designator = 79, RULE_statement = 80, RULE_labeledStatement = 81,
RULE_compoundStatement = 82, RULE_blockItemList = 83, RULE_blockItem = 84,
RULE_expressionStatement = 85, RULE_selectionStatement = 86, RULE_iterationStatement = 87,
RULE_forCondition = 88, RULE_forInit = 89, RULE_forTest = 90, RULE_forIncr = 91,
RULE_forDeclaration = 92, RULE_forExpression = 93, RULE_jumpStatement = 94,
RULE_compilationUnit = 95, RULE_translationUnit = 96, RULE_externalDeclaration = 97,
RULE_functionDefinition = 98;
private static String[] makeRuleNames() {
return new String[] {
"primaryExpression", "postfixExpression", "postfixExpressionAccess",
"postfixExpressionBrackets", "postfixExpressionBraces", "postfixExpressionMemberAccess",
"postfixExpressionPtrMemberAccess", "postfixExpressionIncrement", "postfixExpressionDecrement",
"argumentExpressionList", "unaryExpression", "unaryExpressionIncrement",
"unaryExpressionDecrement", "unaryExpressionCast", "unaryExpressionSizeOrAlignOf",
"unaryOperator", "castExpression", "multiplicativeExpression", "additiveExpression",
"shiftExpression", "relationalExpression", "equalityExpression", "andExpression",
"exclusiveOrExpression", "inclusiveOrExpression", "logicalAndExpression",
"logicalOrExpression", "conditionalExpression", "assignmentExpression",
"assignmentOperator", "expression", "constantExpression", "declaration",
"declarationSpecifiers", "declarationSpecifiers2", "castDeclarationSpecifierList",
"castDeclarationSpecifier", "declarationSpecifier", "initDeclaratorList",
"initDeclarator", "storageClassSpecifier", "typeSpecifier", "typeSpecifierPointer",
"structOrUnionSpecifier", "structOrUnion", "structDeclarationList", "structDeclaration",
"specifierQualifierList", "typeSpecifierOrQualifier", "structDeclaratorList",
"structDeclarator", "enumSpecifier", "enumeratorList", "enumerator",
"enumerationConstant", "atomicTypeSpecifier", "typeQualifier", "functionSpecifier",
"alignmentSpecifier", "declarator", "directDeclarator", "gccDeclaratorExtension",
"gccAttributeSpecifier", "gccAttributeList", "gccAttribute", "nestedParenthesesBlock",
"pointer", "typeQualifierList", "parameterTypeList", "parameterList",
"parameterDeclaration", "typeName", "abstractDeclarator", "directAbstractDeclarator",
"typedefName", "initializer", "initializerList", "designation", "designatorList",
"designator", "statement", "labeledStatement", "compoundStatement", "blockItemList",
"blockItem", "expressionStatement", "selectionStatement", "iterationStatement",
"forCondition", "forInit", "forTest", "forIncr", "forDeclaration", "forExpression",
"jumpStatement", "compilationUnit", "translationUnit", "externalDeclaration",
"functionDefinition"
};
}
public static final String[] ruleNames = makeRuleNames();
private static String[] makeLiteralNames() {
return new String[] {
null, "'__int128'", "'__m128'", "'__m128d'", "'__m128i'", "'__thread'",
"'__typeof__'", "'__inline__'", "'__stdcall'", "'__declspec'", "'__asm'",
"'__asm__'", "'__attribute__'", "'__restrict'", "'__PRETTY_FUNCTION__'",
"'__extension__'", "'auto'", "'break'", "'case'", "'char'", "'const'",
"'continue'", "'default'", "'do'", "'double'", "'else'", "'enum'", "'extern'",
"'float'", "'for'", "'goto'", "'if'", "'inline'", "'int'", "'long'",
"'register'", "'restrict'", "'return'", "'short'", "'signed'", "'sizeof'",
"'static'", "'struct'", "'switch'", "'typedef'", "'union'", "'unsigned'",
"'void'", "'volatile'", "'while'", "'_Alignas'", "'_Alignof'", "'_Atomic'",
"'_Bool'", "'_Complex'", "'_Generic'", "'_Imaginary'", "'_Noreturn'",
"'_Static_assert'", "'_Thread_local'", "'('", "')'", "'['", "']'", "'{'",
"'}'", "'<'", "'<='", "'>'", "'>='", "'<<'", "'>>'", "'+'", "'++'", "'-'",
"'--'", "'*'", "'/'", "'%'", "'&'", "'|'", "'&&'", "'||'", "'^'", "'!'",
"'~'", "'?'", "':'", "';'", "','", "'='", "'*='", "'/='", "'%='", "'+='",
"'-='", "'<<='", "'>>='", "'&='", "'^='", "'|='", "'=='", "'!='", "'->'",
"'.'", "'...'"
};
}
private static final String[] _LITERAL_NAMES = makeLiteralNames();
private static String[] makeSymbolicNames() {
return new String[] {
null, null, null, null, null, null, null, null, null, null, null, null,
null, null, "PRETTY_FUNC", "Extension", "Auto", "Break", "Case", "Char",
"Const", "Continue", "Default", "Do", "Double", "Else", "Enum", "Extern",
"Float", "For", "Goto", "If", "Inline", "Int", "Long", "Register", "Restrict",
"Return", "Short", "Signed", "Sizeof", "Static", "Struct", "Switch",
"Typedef", "Union", "Unsigned", "Void", "Volatile", "While", "Alignas",
"Alignof", "Atomic", "Bool", "Complex", "Generic", "Imaginary", "Noreturn",
"StaticAssert", "ThreadLocal", "LeftParen", "RightParen", "LeftBracket",
"RightBracket", "LeftBrace", "RightBrace", "Less", "LessEqual", "Greater",
"GreaterEqual", "LeftShift", "RightShift", "Plus", "PlusPlus", "Minus",
"MinusMinus", "Star", "Div", "Mod", "And", "Or", "AndAnd", "OrOr", "Caret",
"Not", "Tilde", "Question", "Colon", "Semi", "Comma", "Assign", "StarAssign",
"DivAssign", "ModAssign", "PlusAssign", "MinusAssign", "LeftShiftAssign",
"RightShiftAssign", "AndAssign", "XorAssign", "OrAssign", "Equal", "NotEqual",
"Arrow", "Dot", "Ellipsis", "Identifier", "Constant", "DigitSequence",
"StringLiteral", "ComplexDefine", "IncludeDirective", "AsmBlock", "LineAfterPreprocessing",
"LineDirective", "PragmaDirective", "Whitespace", "Newline", "BlockComment",
"LineComment", "WORD"
};
}
private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
/**
* @deprecated Use {@link #VOCABULARY} instead.
*/
@Deprecated
public static final String[] tokenNames;
static {
tokenNames = new String[_SYMBOLIC_NAMES.length];
for (int i = 0; i < tokenNames.length; i++) {
tokenNames[i] = VOCABULARY.getLiteralName(i);
if (tokenNames[i] == null) {
tokenNames[i] = VOCABULARY.getSymbolicName(i);
}
if (tokenNames[i] == null) {
tokenNames[i] = "";
}
}
}
@Override
@Deprecated
public String[] getTokenNames() {
return tokenNames;
}
@Override
public Vocabulary getVocabulary() {
return VOCABULARY;
}
@Override
public String getGrammarFileName() { return "C.g4"; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
@Override
public ATN getATN() { return _ATN; }
public CParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
}
public static class PrimaryExpressionContext extends ParserRuleContext {
public PrimaryExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primaryExpression; }
public PrimaryExpressionContext() { }
public void copyFrom(PrimaryExpressionContext ctx) {
super.copyFrom(ctx);
}
}
public static class PrimaryExpressionGccExtensionContext extends PrimaryExpressionContext {
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public CompoundStatementContext compoundStatement() {
return getRuleContext(CompoundStatementContext.class,0);
}
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public TerminalNode Extension() { return getToken(CParser.Extension, 0); }
public PrimaryExpressionGccExtensionContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterPrimaryExpressionGccExtension(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitPrimaryExpressionGccExtension(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitPrimaryExpressionGccExtension(this);
else return visitor.visitChildren(this);
}
}
public static class PrimaryExpressionConstantContext extends PrimaryExpressionContext {
public TerminalNode Constant() { return getToken(CParser.Constant, 0); }
public PrimaryExpressionConstantContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterPrimaryExpressionConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitPrimaryExpressionConstant(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitPrimaryExpressionConstant(this);
else return visitor.visitChildren(this);
}
}
public static class PrimaryExpressionBraceExpressionContext extends PrimaryExpressionContext {
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public PrimaryExpressionBraceExpressionContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterPrimaryExpressionBraceExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitPrimaryExpressionBraceExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitPrimaryExpressionBraceExpression(this);
else return visitor.visitChildren(this);
}
}
public static class PrimaryExpressionStringsContext extends PrimaryExpressionContext {
public List StringLiteral() { return getTokens(CParser.StringLiteral); }
public TerminalNode StringLiteral(int i) {
return getToken(CParser.StringLiteral, i);
}
public PrimaryExpressionStringsContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterPrimaryExpressionStrings(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitPrimaryExpressionStrings(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitPrimaryExpressionStrings(this);
else return visitor.visitChildren(this);
}
}
public static class GccPrettyFuncContext extends PrimaryExpressionContext {
public TerminalNode PRETTY_FUNC() { return getToken(CParser.PRETTY_FUNC, 0); }
public GccPrettyFuncContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterGccPrettyFunc(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitGccPrettyFunc(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitGccPrettyFunc(this);
else return visitor.visitChildren(this);
}
}
public static class PrimaryExpressionIdContext extends PrimaryExpressionContext {
public TerminalNode Identifier() { return getToken(CParser.Identifier, 0); }
public PrimaryExpressionIdContext(PrimaryExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterPrimaryExpressionId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitPrimaryExpressionId(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitPrimaryExpressionId(this);
else return visitor.visitChildren(this);
}
}
public final PrimaryExpressionContext primaryExpression() throws RecognitionException {
PrimaryExpressionContext _localctx = new PrimaryExpressionContext(_ctx, getState());
enterRule(_localctx, 0, RULE_primaryExpression);
int _la;
try {
setState(217);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
case 1:
_localctx = new GccPrettyFuncContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(198);
match(PRETTY_FUNC);
}
break;
case 2:
_localctx = new PrimaryExpressionIdContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(199);
match(Identifier);
}
break;
case 3:
_localctx = new PrimaryExpressionConstantContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(200);
match(Constant);
}
break;
case 4:
_localctx = new PrimaryExpressionStringsContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(202);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(201);
match(StringLiteral);
}
}
setState(204);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==StringLiteral );
}
break;
case 5:
_localctx = new PrimaryExpressionBraceExpressionContext(_localctx);
enterOuterAlt(_localctx, 5);
{
setState(206);
match(LeftParen);
setState(207);
expression();
setState(208);
match(RightParen);
}
break;
case 6:
_localctx = new PrimaryExpressionGccExtensionContext(_localctx);
enterOuterAlt(_localctx, 6);
{
setState(211);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Extension) {
{
setState(210);
match(Extension);
}
}
setState(213);
match(LeftParen);
setState(214);
compoundStatement();
setState(215);
match(RightParen);
}
break;
}
}
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 PostfixExpressionAccessContext postfixExpressionAccess;
public List pfExprs = new ArrayList();
public PrimaryExpressionContext primaryExpression() {
return getRuleContext(PrimaryExpressionContext.class,0);
}
public List postfixExpressionAccess() {
return getRuleContexts(PostfixExpressionAccessContext.class);
}
public PostfixExpressionAccessContext postfixExpressionAccess(int i) {
return getRuleContext(PostfixExpressionAccessContext.class,i);
}
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 CListener ) ((CListener)listener).enterPostfixExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitPostfixExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitPostfixExpression(this);
else return visitor.visitChildren(this);
}
}
public final PostfixExpressionContext postfixExpression() throws RecognitionException {
PostfixExpressionContext _localctx = new PostfixExpressionContext(_ctx, getState());
enterRule(_localctx, 2, RULE_postfixExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(219);
primaryExpression();
setState(223);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 60)) & ~0x3f) == 0 && ((1L << (_la - 60)) & ((1L << (LeftParen - 60)) | (1L << (LeftBracket - 60)) | (1L << (PlusPlus - 60)) | (1L << (MinusMinus - 60)) | (1L << (Arrow - 60)) | (1L << (Dot - 60)))) != 0)) {
{
{
setState(220);
((PostfixExpressionContext)_localctx).postfixExpressionAccess = postfixExpressionAccess();
((PostfixExpressionContext)_localctx).pfExprs.add(((PostfixExpressionContext)_localctx).postfixExpressionAccess);
}
}
setState(225);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PostfixExpressionAccessContext extends ParserRuleContext {
public PostfixExpressionBracketsContext postfixExpressionBrackets() {
return getRuleContext(PostfixExpressionBracketsContext.class,0);
}
public PostfixExpressionBracesContext postfixExpressionBraces() {
return getRuleContext(PostfixExpressionBracesContext.class,0);
}
public PostfixExpressionMemberAccessContext postfixExpressionMemberAccess() {
return getRuleContext(PostfixExpressionMemberAccessContext.class,0);
}
public PostfixExpressionPtrMemberAccessContext postfixExpressionPtrMemberAccess() {
return getRuleContext(PostfixExpressionPtrMemberAccessContext.class,0);
}
public PostfixExpressionIncrementContext postfixExpressionIncrement() {
return getRuleContext(PostfixExpressionIncrementContext.class,0);
}
public PostfixExpressionDecrementContext postfixExpressionDecrement() {
return getRuleContext(PostfixExpressionDecrementContext.class,0);
}
public PostfixExpressionAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postfixExpressionAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterPostfixExpressionAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitPostfixExpressionAccess(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitPostfixExpressionAccess(this);
else return visitor.visitChildren(this);
}
}
public final PostfixExpressionAccessContext postfixExpressionAccess() throws RecognitionException {
PostfixExpressionAccessContext _localctx = new PostfixExpressionAccessContext(_ctx, getState());
enterRule(_localctx, 4, RULE_postfixExpressionAccess);
try {
setState(232);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LeftBracket:
enterOuterAlt(_localctx, 1);
{
setState(226);
postfixExpressionBrackets();
}
break;
case LeftParen:
enterOuterAlt(_localctx, 2);
{
setState(227);
postfixExpressionBraces();
}
break;
case Dot:
enterOuterAlt(_localctx, 3);
{
setState(228);
postfixExpressionMemberAccess();
}
break;
case Arrow:
enterOuterAlt(_localctx, 4);
{
setState(229);
postfixExpressionPtrMemberAccess();
}
break;
case PlusPlus:
enterOuterAlt(_localctx, 5);
{
setState(230);
postfixExpressionIncrement();
}
break;
case MinusMinus:
enterOuterAlt(_localctx, 6);
{
setState(231);
postfixExpressionDecrement();
}
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 PostfixExpressionBracketsContext extends ParserRuleContext {
public TerminalNode LeftBracket() { return getToken(CParser.LeftBracket, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RightBracket() { return getToken(CParser.RightBracket, 0); }
public PostfixExpressionBracketsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postfixExpressionBrackets; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterPostfixExpressionBrackets(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitPostfixExpressionBrackets(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitPostfixExpressionBrackets(this);
else return visitor.visitChildren(this);
}
}
public final PostfixExpressionBracketsContext postfixExpressionBrackets() throws RecognitionException {
PostfixExpressionBracketsContext _localctx = new PostfixExpressionBracketsContext(_ctx, getState());
enterRule(_localctx, 6, RULE_postfixExpressionBrackets);
try {
enterOuterAlt(_localctx, 1);
{
setState(234);
match(LeftBracket);
setState(235);
expression();
setState(236);
match(RightBracket);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PostfixExpressionBracesContext extends ParserRuleContext {
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public ArgumentExpressionListContext argumentExpressionList() {
return getRuleContext(ArgumentExpressionListContext.class,0);
}
public PostfixExpressionBracesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postfixExpressionBraces; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterPostfixExpressionBraces(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitPostfixExpressionBraces(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitPostfixExpressionBraces(this);
else return visitor.visitChildren(this);
}
}
public final PostfixExpressionBracesContext postfixExpressionBraces() throws RecognitionException {
PostfixExpressionBracesContext _localctx = new PostfixExpressionBracesContext(_ctx, getState());
enterRule(_localctx, 8, RULE_postfixExpressionBraces);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(238);
match(LeftParen);
setState(240);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRETTY_FUNC) | (1L << Extension) | (1L << Sizeof) | (1L << Alignof) | (1L << LeftParen))) != 0) || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (Plus - 72)) | (1L << (PlusPlus - 72)) | (1L << (Minus - 72)) | (1L << (MinusMinus - 72)) | (1L << (Star - 72)) | (1L << (And - 72)) | (1L << (Not - 72)) | (1L << (Tilde - 72)) | (1L << (Identifier - 72)) | (1L << (Constant - 72)) | (1L << (StringLiteral - 72)))) != 0)) {
{
setState(239);
argumentExpressionList();
}
}
setState(242);
match(RightParen);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PostfixExpressionMemberAccessContext extends ParserRuleContext {
public TerminalNode Dot() { return getToken(CParser.Dot, 0); }
public TerminalNode Identifier() { return getToken(CParser.Identifier, 0); }
public PostfixExpressionMemberAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postfixExpressionMemberAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterPostfixExpressionMemberAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitPostfixExpressionMemberAccess(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitPostfixExpressionMemberAccess(this);
else return visitor.visitChildren(this);
}
}
public final PostfixExpressionMemberAccessContext postfixExpressionMemberAccess() throws RecognitionException {
PostfixExpressionMemberAccessContext _localctx = new PostfixExpressionMemberAccessContext(_ctx, getState());
enterRule(_localctx, 10, RULE_postfixExpressionMemberAccess);
try {
enterOuterAlt(_localctx, 1);
{
setState(244);
match(Dot);
setState(245);
match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PostfixExpressionPtrMemberAccessContext extends ParserRuleContext {
public TerminalNode Arrow() { return getToken(CParser.Arrow, 0); }
public TerminalNode Identifier() { return getToken(CParser.Identifier, 0); }
public PostfixExpressionPtrMemberAccessContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postfixExpressionPtrMemberAccess; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterPostfixExpressionPtrMemberAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitPostfixExpressionPtrMemberAccess(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitPostfixExpressionPtrMemberAccess(this);
else return visitor.visitChildren(this);
}
}
public final PostfixExpressionPtrMemberAccessContext postfixExpressionPtrMemberAccess() throws RecognitionException {
PostfixExpressionPtrMemberAccessContext _localctx = new PostfixExpressionPtrMemberAccessContext(_ctx, getState());
enterRule(_localctx, 12, RULE_postfixExpressionPtrMemberAccess);
try {
enterOuterAlt(_localctx, 1);
{
setState(247);
match(Arrow);
setState(248);
match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PostfixExpressionIncrementContext extends ParserRuleContext {
public TerminalNode PlusPlus() { return getToken(CParser.PlusPlus, 0); }
public PostfixExpressionIncrementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postfixExpressionIncrement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterPostfixExpressionIncrement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitPostfixExpressionIncrement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitPostfixExpressionIncrement(this);
else return visitor.visitChildren(this);
}
}
public final PostfixExpressionIncrementContext postfixExpressionIncrement() throws RecognitionException {
PostfixExpressionIncrementContext _localctx = new PostfixExpressionIncrementContext(_ctx, getState());
enterRule(_localctx, 14, RULE_postfixExpressionIncrement);
try {
enterOuterAlt(_localctx, 1);
{
setState(250);
match(PlusPlus);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PostfixExpressionDecrementContext extends ParserRuleContext {
public TerminalNode MinusMinus() { return getToken(CParser.MinusMinus, 0); }
public PostfixExpressionDecrementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postfixExpressionDecrement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterPostfixExpressionDecrement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitPostfixExpressionDecrement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitPostfixExpressionDecrement(this);
else return visitor.visitChildren(this);
}
}
public final PostfixExpressionDecrementContext postfixExpressionDecrement() throws RecognitionException {
PostfixExpressionDecrementContext _localctx = new PostfixExpressionDecrementContext(_ctx, getState());
enterRule(_localctx, 16, RULE_postfixExpressionDecrement);
try {
enterOuterAlt(_localctx, 1);
{
setState(252);
match(MinusMinus);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ArgumentExpressionListContext extends ParserRuleContext {
public List assignmentExpression() {
return getRuleContexts(AssignmentExpressionContext.class);
}
public AssignmentExpressionContext assignmentExpression(int i) {
return getRuleContext(AssignmentExpressionContext.class,i);
}
public List Comma() { return getTokens(CParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(CParser.Comma, i);
}
public ArgumentExpressionListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_argumentExpressionList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterArgumentExpressionList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitArgumentExpressionList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitArgumentExpressionList(this);
else return visitor.visitChildren(this);
}
}
public final ArgumentExpressionListContext argumentExpressionList() throws RecognitionException {
ArgumentExpressionListContext _localctx = new ArgumentExpressionListContext(_ctx, getState());
enterRule(_localctx, 18, RULE_argumentExpressionList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(254);
assignmentExpression();
setState(259);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Comma) {
{
{
setState(255);
match(Comma);
setState(256);
assignmentExpression();
}
}
setState(261);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
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 UnaryExpressionCastContext unaryExpressionCast() {
return getRuleContext(UnaryExpressionCastContext.class,0);
}
public UnaryExpressionSizeOrAlignOfContext unaryExpressionSizeOrAlignOf() {
return getRuleContext(UnaryExpressionSizeOrAlignOfContext.class,0);
}
public List unaryExpressionIncrement() {
return getRuleContexts(UnaryExpressionIncrementContext.class);
}
public UnaryExpressionIncrementContext unaryExpressionIncrement(int i) {
return getRuleContext(UnaryExpressionIncrementContext.class,i);
}
public List unaryExpressionDecrement() {
return getRuleContexts(UnaryExpressionDecrementContext.class);
}
public UnaryExpressionDecrementContext unaryExpressionDecrement(int i) {
return getRuleContext(UnaryExpressionDecrementContext.class,i);
}
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 CListener ) ((CListener)listener).enterUnaryExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitUnaryExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitUnaryExpression(this);
else return visitor.visitChildren(this);
}
}
public final UnaryExpressionContext unaryExpression() throws RecognitionException {
UnaryExpressionContext _localctx = new UnaryExpressionContext(_ctx, getState());
enterRule(_localctx, 20, RULE_unaryExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(266);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==PlusPlus || _la==MinusMinus) {
{
setState(264);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PlusPlus:
{
setState(262);
unaryExpressionIncrement();
}
break;
case MinusMinus:
{
setState(263);
unaryExpressionDecrement();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(268);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(272);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PRETTY_FUNC:
case Extension:
case LeftParen:
case Identifier:
case Constant:
case StringLiteral:
{
setState(269);
postfixExpression();
}
break;
case Plus:
case Minus:
case Star:
case And:
case Not:
case Tilde:
{
setState(270);
unaryExpressionCast();
}
break;
case Sizeof:
case Alignof:
{
setState(271);
unaryExpressionSizeOrAlignOf();
}
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 UnaryExpressionIncrementContext extends ParserRuleContext {
public TerminalNode PlusPlus() { return getToken(CParser.PlusPlus, 0); }
public UnaryExpressionIncrementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryExpressionIncrement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterUnaryExpressionIncrement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitUnaryExpressionIncrement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitUnaryExpressionIncrement(this);
else return visitor.visitChildren(this);
}
}
public final UnaryExpressionIncrementContext unaryExpressionIncrement() throws RecognitionException {
UnaryExpressionIncrementContext _localctx = new UnaryExpressionIncrementContext(_ctx, getState());
enterRule(_localctx, 22, RULE_unaryExpressionIncrement);
try {
enterOuterAlt(_localctx, 1);
{
setState(274);
match(PlusPlus);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnaryExpressionDecrementContext extends ParserRuleContext {
public TerminalNode MinusMinus() { return getToken(CParser.MinusMinus, 0); }
public UnaryExpressionDecrementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryExpressionDecrement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterUnaryExpressionDecrement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitUnaryExpressionDecrement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitUnaryExpressionDecrement(this);
else return visitor.visitChildren(this);
}
}
public final UnaryExpressionDecrementContext unaryExpressionDecrement() throws RecognitionException {
UnaryExpressionDecrementContext _localctx = new UnaryExpressionDecrementContext(_ctx, getState());
enterRule(_localctx, 24, RULE_unaryExpressionDecrement);
try {
enterOuterAlt(_localctx, 1);
{
setState(276);
match(MinusMinus);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnaryExpressionCastContext extends ParserRuleContext {
public UnaryOperatorContext unaryOperator() {
return getRuleContext(UnaryOperatorContext.class,0);
}
public CastExpressionContext castExpression() {
return getRuleContext(CastExpressionContext.class,0);
}
public UnaryExpressionCastContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryExpressionCast; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterUnaryExpressionCast(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitUnaryExpressionCast(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitUnaryExpressionCast(this);
else return visitor.visitChildren(this);
}
}
public final UnaryExpressionCastContext unaryExpressionCast() throws RecognitionException {
UnaryExpressionCastContext _localctx = new UnaryExpressionCastContext(_ctx, getState());
enterRule(_localctx, 26, RULE_unaryExpressionCast);
try {
enterOuterAlt(_localctx, 1);
{
setState(278);
unaryOperator();
setState(279);
castExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class UnaryExpressionSizeOrAlignOfContext extends ParserRuleContext {
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public TerminalNode Sizeof() { return getToken(CParser.Sizeof, 0); }
public TerminalNode Alignof() { return getToken(CParser.Alignof, 0); }
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public UnaryExpressionSizeOrAlignOfContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unaryExpressionSizeOrAlignOf; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterUnaryExpressionSizeOrAlignOf(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitUnaryExpressionSizeOrAlignOf(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitUnaryExpressionSizeOrAlignOf(this);
else return visitor.visitChildren(this);
}
}
public final UnaryExpressionSizeOrAlignOfContext unaryExpressionSizeOrAlignOf() throws RecognitionException {
UnaryExpressionSizeOrAlignOfContext _localctx = new UnaryExpressionSizeOrAlignOfContext(_ctx, getState());
enterRule(_localctx, 28, RULE_unaryExpressionSizeOrAlignOf);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(281);
_la = _input.LA(1);
if ( !(_la==Sizeof || _la==Alignof) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(282);
match(LeftParen);
setState(285);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
case 1:
{
setState(283);
typeName();
}
break;
case 2:
{
setState(284);
expression();
}
break;
}
setState(287);
match(RightParen);
}
}
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 TerminalNode And() { return getToken(CParser.And, 0); }
public TerminalNode Star() { return getToken(CParser.Star, 0); }
public TerminalNode Plus() { return getToken(CParser.Plus, 0); }
public TerminalNode Minus() { return getToken(CParser.Minus, 0); }
public TerminalNode Tilde() { return getToken(CParser.Tilde, 0); }
public TerminalNode Not() { return getToken(CParser.Not, 0); }
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 CListener ) ((CListener)listener).enterUnaryOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitUnaryOperator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitUnaryOperator(this);
else return visitor.visitChildren(this);
}
}
public final UnaryOperatorContext unaryOperator() throws RecognitionException {
UnaryOperatorContext _localctx = new UnaryOperatorContext(_ctx, getState());
enterRule(_localctx, 30, RULE_unaryOperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(289);
_la = _input.LA(1);
if ( !(((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (Plus - 72)) | (1L << (Minus - 72)) | (1L << (Star - 72)) | (1L << (And - 72)) | (1L << (Not - 72)) | (1L << (Tilde - 72)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CastExpressionContext extends ParserRuleContext {
public CastExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_castExpression; }
public CastExpressionContext() { }
public void copyFrom(CastExpressionContext ctx) {
super.copyFrom(ctx);
}
}
public static class CastExpressionCastContext extends CastExpressionContext {
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public CastDeclarationSpecifierListContext castDeclarationSpecifierList() {
return getRuleContext(CastDeclarationSpecifierListContext.class,0);
}
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public CastExpressionContext castExpression() {
return getRuleContext(CastExpressionContext.class,0);
}
public TerminalNode Extension() { return getToken(CParser.Extension, 0); }
public CastExpressionCastContext(CastExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterCastExpressionCast(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitCastExpressionCast(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitCastExpressionCast(this);
else return visitor.visitChildren(this);
}
}
public static class CastExpressionUnaryExpressionContext extends CastExpressionContext {
public UnaryExpressionContext unaryExpression() {
return getRuleContext(UnaryExpressionContext.class,0);
}
public CastExpressionUnaryExpressionContext(CastExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterCastExpressionUnaryExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitCastExpressionUnaryExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitCastExpressionUnaryExpression(this);
else return visitor.visitChildren(this);
}
}
public final CastExpressionContext castExpression() throws RecognitionException {
CastExpressionContext _localctx = new CastExpressionContext(_ctx, getState());
enterRule(_localctx, 32, RULE_castExpression);
int _la;
try {
setState(300);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
case 1:
_localctx = new CastExpressionCastContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(292);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Extension) {
{
setState(291);
match(Extension);
}
}
setState(294);
match(LeftParen);
setState(295);
castDeclarationSpecifierList();
setState(296);
match(RightParen);
setState(297);
castExpression();
}
break;
case 2:
_localctx = new CastExpressionUnaryExpressionContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(299);
unaryExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class MultiplicativeExpressionContext extends ParserRuleContext {
public Token s76;
public List signs = new ArrayList();
public Token s77;
public Token s78;
public Token _tset384;
public List castExpression() {
return getRuleContexts(CastExpressionContext.class);
}
public CastExpressionContext castExpression(int i) {
return getRuleContext(CastExpressionContext.class,i);
}
public List Star() { return getTokens(CParser.Star); }
public TerminalNode Star(int i) {
return getToken(CParser.Star, i);
}
public List Div() { return getTokens(CParser.Div); }
public TerminalNode Div(int i) {
return getToken(CParser.Div, i);
}
public List Mod() { return getTokens(CParser.Mod); }
public TerminalNode Mod(int i) {
return getToken(CParser.Mod, i);
}
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 CListener ) ((CListener)listener).enterMultiplicativeExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitMultiplicativeExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitMultiplicativeExpression(this);
else return visitor.visitChildren(this);
}
}
public final MultiplicativeExpressionContext multiplicativeExpression() throws RecognitionException {
MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(_ctx, getState());
enterRule(_localctx, 34, RULE_multiplicativeExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(302);
castExpression();
setState(307);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (Star - 76)) | (1L << (Div - 76)) | (1L << (Mod - 76)))) != 0)) {
{
{
setState(303);
((MultiplicativeExpressionContext)_localctx)._tset384 = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 76)) & ~0x3f) == 0 && ((1L << (_la - 76)) & ((1L << (Star - 76)) | (1L << (Div - 76)) | (1L << (Mod - 76)))) != 0)) ) {
((MultiplicativeExpressionContext)_localctx)._tset384 = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
((MultiplicativeExpressionContext)_localctx).signs.add(((MultiplicativeExpressionContext)_localctx)._tset384);
setState(304);
castExpression();
}
}
setState(309);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AdditiveExpressionContext extends ParserRuleContext {
public Token s72;
public List signs = new ArrayList();
public Token s74;
public Token _tset407;
public List multiplicativeExpression() {
return getRuleContexts(MultiplicativeExpressionContext.class);
}
public MultiplicativeExpressionContext multiplicativeExpression(int i) {
return getRuleContext(MultiplicativeExpressionContext.class,i);
}
public List Plus() { return getTokens(CParser.Plus); }
public TerminalNode Plus(int i) {
return getToken(CParser.Plus, i);
}
public List Minus() { return getTokens(CParser.Minus); }
public TerminalNode Minus(int i) {
return getToken(CParser.Minus, i);
}
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 CListener ) ((CListener)listener).enterAdditiveExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitAdditiveExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitAdditiveExpression(this);
else return visitor.visitChildren(this);
}
}
public final AdditiveExpressionContext additiveExpression() throws RecognitionException {
AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, getState());
enterRule(_localctx, 36, RULE_additiveExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(310);
multiplicativeExpression();
setState(315);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Plus || _la==Minus) {
{
{
setState(311);
((AdditiveExpressionContext)_localctx)._tset407 = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==Plus || _la==Minus) ) {
((AdditiveExpressionContext)_localctx)._tset407 = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
((AdditiveExpressionContext)_localctx).signs.add(((AdditiveExpressionContext)_localctx)._tset407);
setState(312);
multiplicativeExpression();
}
}
setState(317);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ShiftExpressionContext extends ParserRuleContext {
public Token s70;
public List signs = new ArrayList();
public Token s71;
public Token _tset428;
public List additiveExpression() {
return getRuleContexts(AdditiveExpressionContext.class);
}
public AdditiveExpressionContext additiveExpression(int i) {
return getRuleContext(AdditiveExpressionContext.class,i);
}
public List LeftShift() { return getTokens(CParser.LeftShift); }
public TerminalNode LeftShift(int i) {
return getToken(CParser.LeftShift, i);
}
public List RightShift() { return getTokens(CParser.RightShift); }
public TerminalNode RightShift(int i) {
return getToken(CParser.RightShift, i);
}
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 CListener ) ((CListener)listener).enterShiftExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitShiftExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitShiftExpression(this);
else return visitor.visitChildren(this);
}
}
public final ShiftExpressionContext shiftExpression() throws RecognitionException {
ShiftExpressionContext _localctx = new ShiftExpressionContext(_ctx, getState());
enterRule(_localctx, 38, RULE_shiftExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(318);
additiveExpression();
setState(323);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==LeftShift || _la==RightShift) {
{
{
setState(319);
((ShiftExpressionContext)_localctx)._tset428 = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==LeftShift || _la==RightShift) ) {
((ShiftExpressionContext)_localctx)._tset428 = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
((ShiftExpressionContext)_localctx).signs.add(((ShiftExpressionContext)_localctx)._tset428);
setState(320);
additiveExpression();
}
}
setState(325);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class RelationalExpressionContext extends ParserRuleContext {
public Token s66;
public List signs = new ArrayList();
public Token s68;
public Token s67;
public Token s69;
public Token _tset449;
public List shiftExpression() {
return getRuleContexts(ShiftExpressionContext.class);
}
public ShiftExpressionContext shiftExpression(int i) {
return getRuleContext(ShiftExpressionContext.class,i);
}
public List Less() { return getTokens(CParser.Less); }
public TerminalNode Less(int i) {
return getToken(CParser.Less, i);
}
public List Greater() { return getTokens(CParser.Greater); }
public TerminalNode Greater(int i) {
return getToken(CParser.Greater, i);
}
public List LessEqual() { return getTokens(CParser.LessEqual); }
public TerminalNode LessEqual(int i) {
return getToken(CParser.LessEqual, i);
}
public List GreaterEqual() { return getTokens(CParser.GreaterEqual); }
public TerminalNode GreaterEqual(int i) {
return getToken(CParser.GreaterEqual, i);
}
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 CListener ) ((CListener)listener).enterRelationalExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitRelationalExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitRelationalExpression(this);
else return visitor.visitChildren(this);
}
}
public final RelationalExpressionContext relationalExpression() throws RecognitionException {
RelationalExpressionContext _localctx = new RelationalExpressionContext(_ctx, getState());
enterRule(_localctx, 40, RULE_relationalExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(326);
shiftExpression();
setState(331);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (Less - 66)) | (1L << (LessEqual - 66)) | (1L << (Greater - 66)) | (1L << (GreaterEqual - 66)))) != 0)) {
{
{
setState(327);
((RelationalExpressionContext)_localctx)._tset449 = _input.LT(1);
_la = _input.LA(1);
if ( !(((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (Less - 66)) | (1L << (LessEqual - 66)) | (1L << (Greater - 66)) | (1L << (GreaterEqual - 66)))) != 0)) ) {
((RelationalExpressionContext)_localctx)._tset449 = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
((RelationalExpressionContext)_localctx).signs.add(((RelationalExpressionContext)_localctx)._tset449);
setState(328);
shiftExpression();
}
}
setState(333);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EqualityExpressionContext extends ParserRuleContext {
public Token s101;
public List signs = new ArrayList();
public Token s102;
public Token _tset474;
public List relationalExpression() {
return getRuleContexts(RelationalExpressionContext.class);
}
public RelationalExpressionContext relationalExpression(int i) {
return getRuleContext(RelationalExpressionContext.class,i);
}
public List Equal() { return getTokens(CParser.Equal); }
public TerminalNode Equal(int i) {
return getToken(CParser.Equal, i);
}
public List NotEqual() { return getTokens(CParser.NotEqual); }
public TerminalNode NotEqual(int i) {
return getToken(CParser.NotEqual, i);
}
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 CListener ) ((CListener)listener).enterEqualityExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitEqualityExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitEqualityExpression(this);
else return visitor.visitChildren(this);
}
}
public final EqualityExpressionContext equalityExpression() throws RecognitionException {
EqualityExpressionContext _localctx = new EqualityExpressionContext(_ctx, getState());
enterRule(_localctx, 42, RULE_equalityExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(334);
relationalExpression();
setState(339);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Equal || _la==NotEqual) {
{
{
setState(335);
((EqualityExpressionContext)_localctx)._tset474 = _input.LT(1);
_la = _input.LA(1);
if ( !(_la==Equal || _la==NotEqual) ) {
((EqualityExpressionContext)_localctx)._tset474 = (Token)_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
((EqualityExpressionContext)_localctx).signs.add(((EqualityExpressionContext)_localctx)._tset474);
setState(336);
relationalExpression();
}
}
setState(341);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AndExpressionContext extends ParserRuleContext {
public List equalityExpression() {
return getRuleContexts(EqualityExpressionContext.class);
}
public EqualityExpressionContext equalityExpression(int i) {
return getRuleContext(EqualityExpressionContext.class,i);
}
public List And() { return getTokens(CParser.And); }
public TerminalNode And(int i) {
return getToken(CParser.And, i);
}
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 CListener ) ((CListener)listener).enterAndExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitAndExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitAndExpression(this);
else return visitor.visitChildren(this);
}
}
public final AndExpressionContext andExpression() throws RecognitionException {
AndExpressionContext _localctx = new AndExpressionContext(_ctx, getState());
enterRule(_localctx, 44, RULE_andExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(342);
equalityExpression();
setState(347);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==And) {
{
{
setState(343);
match(And);
setState(344);
equalityExpression();
}
}
setState(349);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExclusiveOrExpressionContext extends ParserRuleContext {
public List andExpression() {
return getRuleContexts(AndExpressionContext.class);
}
public AndExpressionContext andExpression(int i) {
return getRuleContext(AndExpressionContext.class,i);
}
public List Caret() { return getTokens(CParser.Caret); }
public TerminalNode Caret(int i) {
return getToken(CParser.Caret, i);
}
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 CListener ) ((CListener)listener).enterExclusiveOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitExclusiveOrExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitExclusiveOrExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExclusiveOrExpressionContext exclusiveOrExpression() throws RecognitionException {
ExclusiveOrExpressionContext _localctx = new ExclusiveOrExpressionContext(_ctx, getState());
enterRule(_localctx, 46, RULE_exclusiveOrExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(350);
andExpression();
setState(355);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Caret) {
{
{
setState(351);
match(Caret);
setState(352);
andExpression();
}
}
setState(357);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InclusiveOrExpressionContext extends ParserRuleContext {
public List exclusiveOrExpression() {
return getRuleContexts(ExclusiveOrExpressionContext.class);
}
public ExclusiveOrExpressionContext exclusiveOrExpression(int i) {
return getRuleContext(ExclusiveOrExpressionContext.class,i);
}
public List Or() { return getTokens(CParser.Or); }
public TerminalNode Or(int i) {
return getToken(CParser.Or, i);
}
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 CListener ) ((CListener)listener).enterInclusiveOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitInclusiveOrExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitInclusiveOrExpression(this);
else return visitor.visitChildren(this);
}
}
public final InclusiveOrExpressionContext inclusiveOrExpression() throws RecognitionException {
InclusiveOrExpressionContext _localctx = new InclusiveOrExpressionContext(_ctx, getState());
enterRule(_localctx, 48, RULE_inclusiveOrExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(358);
exclusiveOrExpression();
setState(363);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Or) {
{
{
setState(359);
match(Or);
setState(360);
exclusiveOrExpression();
}
}
setState(365);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LogicalAndExpressionContext extends ParserRuleContext {
public List inclusiveOrExpression() {
return getRuleContexts(InclusiveOrExpressionContext.class);
}
public InclusiveOrExpressionContext inclusiveOrExpression(int i) {
return getRuleContext(InclusiveOrExpressionContext.class,i);
}
public List AndAnd() { return getTokens(CParser.AndAnd); }
public TerminalNode AndAnd(int i) {
return getToken(CParser.AndAnd, i);
}
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 CListener ) ((CListener)listener).enterLogicalAndExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitLogicalAndExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitLogicalAndExpression(this);
else return visitor.visitChildren(this);
}
}
public final LogicalAndExpressionContext logicalAndExpression() throws RecognitionException {
LogicalAndExpressionContext _localctx = new LogicalAndExpressionContext(_ctx, getState());
enterRule(_localctx, 50, RULE_logicalAndExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(366);
inclusiveOrExpression();
setState(371);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==AndAnd) {
{
{
setState(367);
match(AndAnd);
setState(368);
inclusiveOrExpression();
}
}
setState(373);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class LogicalOrExpressionContext extends ParserRuleContext {
public List logicalAndExpression() {
return getRuleContexts(LogicalAndExpressionContext.class);
}
public LogicalAndExpressionContext logicalAndExpression(int i) {
return getRuleContext(LogicalAndExpressionContext.class,i);
}
public List OrOr() { return getTokens(CParser.OrOr); }
public TerminalNode OrOr(int i) {
return getToken(CParser.OrOr, i);
}
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 CListener ) ((CListener)listener).enterLogicalOrExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitLogicalOrExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitLogicalOrExpression(this);
else return visitor.visitChildren(this);
}
}
public final LogicalOrExpressionContext logicalOrExpression() throws RecognitionException {
LogicalOrExpressionContext _localctx = new LogicalOrExpressionContext(_ctx, getState());
enterRule(_localctx, 52, RULE_logicalOrExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(374);
logicalAndExpression();
setState(379);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==OrOr) {
{
{
setState(375);
match(OrOr);
setState(376);
logicalAndExpression();
}
}
setState(381);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConditionalExpressionContext extends ParserRuleContext {
public LogicalOrExpressionContext logicalOrExpression() {
return getRuleContext(LogicalOrExpressionContext.class,0);
}
public TerminalNode Question() { return getToken(CParser.Question, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode Colon() { return getToken(CParser.Colon, 0); }
public ConditionalExpressionContext conditionalExpression() {
return getRuleContext(ConditionalExpressionContext.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 CListener ) ((CListener)listener).enterConditionalExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitConditionalExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitConditionalExpression(this);
else return visitor.visitChildren(this);
}
}
public final ConditionalExpressionContext conditionalExpression() throws RecognitionException {
ConditionalExpressionContext _localctx = new ConditionalExpressionContext(_ctx, getState());
enterRule(_localctx, 54, RULE_conditionalExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(382);
logicalOrExpression();
setState(388);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Question) {
{
setState(383);
match(Question);
setState(384);
expression();
setState(385);
match(Colon);
setState(386);
conditionalExpression();
}
}
}
}
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 AssignmentExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignmentExpression; }
public AssignmentExpressionContext() { }
public void copyFrom(AssignmentExpressionContext ctx) {
super.copyFrom(ctx);
}
}
public static class AssignmentExpressionConditionalExpressionContext extends AssignmentExpressionContext {
public ConditionalExpressionContext conditionalExpression() {
return getRuleContext(ConditionalExpressionContext.class,0);
}
public AssignmentExpressionConditionalExpressionContext(AssignmentExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterAssignmentExpressionConditionalExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitAssignmentExpressionConditionalExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitAssignmentExpressionConditionalExpression(this);
else return visitor.visitChildren(this);
}
}
public static class AssignmentExpressionAssignmentExpressionContext extends AssignmentExpressionContext {
public UnaryExpressionContext unaryExpression() {
return getRuleContext(UnaryExpressionContext.class,0);
}
public AssignmentOperatorContext assignmentOperator() {
return getRuleContext(AssignmentOperatorContext.class,0);
}
public AssignmentExpressionContext assignmentExpression() {
return getRuleContext(AssignmentExpressionContext.class,0);
}
public AssignmentExpressionAssignmentExpressionContext(AssignmentExpressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterAssignmentExpressionAssignmentExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitAssignmentExpressionAssignmentExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitAssignmentExpressionAssignmentExpression(this);
else return visitor.visitChildren(this);
}
}
public final AssignmentExpressionContext assignmentExpression() throws RecognitionException {
AssignmentExpressionContext _localctx = new AssignmentExpressionContext(_ctx, getState());
enterRule(_localctx, 56, RULE_assignmentExpression);
try {
setState(395);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
case 1:
_localctx = new AssignmentExpressionConditionalExpressionContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(390);
conditionalExpression();
}
break;
case 2:
_localctx = new AssignmentExpressionAssignmentExpressionContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(391);
unaryExpression();
setState(392);
assignmentOperator();
setState(393);
assignmentExpression();
}
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 TerminalNode Assign() { return getToken(CParser.Assign, 0); }
public TerminalNode StarAssign() { return getToken(CParser.StarAssign, 0); }
public TerminalNode DivAssign() { return getToken(CParser.DivAssign, 0); }
public TerminalNode ModAssign() { return getToken(CParser.ModAssign, 0); }
public TerminalNode PlusAssign() { return getToken(CParser.PlusAssign, 0); }
public TerminalNode MinusAssign() { return getToken(CParser.MinusAssign, 0); }
public TerminalNode LeftShiftAssign() { return getToken(CParser.LeftShiftAssign, 0); }
public TerminalNode RightShiftAssign() { return getToken(CParser.RightShiftAssign, 0); }
public TerminalNode AndAssign() { return getToken(CParser.AndAssign, 0); }
public TerminalNode XorAssign() { return getToken(CParser.XorAssign, 0); }
public TerminalNode OrAssign() { return getToken(CParser.OrAssign, 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 CListener ) ((CListener)listener).enterAssignmentOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitAssignmentOperator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitAssignmentOperator(this);
else return visitor.visitChildren(this);
}
}
public final AssignmentOperatorContext assignmentOperator() throws RecognitionException {
AssignmentOperatorContext _localctx = new AssignmentOperatorContext(_ctx, getState());
enterRule(_localctx, 58, RULE_assignmentOperator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(397);
_la = _input.LA(1);
if ( !(((((_la - 90)) & ~0x3f) == 0 && ((1L << (_la - 90)) & ((1L << (Assign - 90)) | (1L << (StarAssign - 90)) | (1L << (DivAssign - 90)) | (1L << (ModAssign - 90)) | (1L << (PlusAssign - 90)) | (1L << (MinusAssign - 90)) | (1L << (LeftShiftAssign - 90)) | (1L << (RightShiftAssign - 90)) | (1L << (AndAssign - 90)) | (1L << (XorAssign - 90)) | (1L << (OrAssign - 90)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExpressionContext extends ParserRuleContext {
public List assignmentExpression() {
return getRuleContexts(AssignmentExpressionContext.class);
}
public AssignmentExpressionContext assignmentExpression(int i) {
return getRuleContext(AssignmentExpressionContext.class,i);
}
public List Comma() { return getTokens(CParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(CParser.Comma, i);
}
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 CListener ) ((CListener)listener).enterExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitExpression(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionContext expression() throws RecognitionException {
ExpressionContext _localctx = new ExpressionContext(_ctx, getState());
enterRule(_localctx, 60, RULE_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(399);
assignmentExpression();
setState(404);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Comma) {
{
{
setState(400);
match(Comma);
setState(401);
assignmentExpression();
}
}
setState(406);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
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 CListener ) ((CListener)listener).enterConstantExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitConstantExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitConstantExpression(this);
else return visitor.visitChildren(this);
}
}
public final ConstantExpressionContext constantExpression() throws RecognitionException {
ConstantExpressionContext _localctx = new ConstantExpressionContext(_ctx, getState());
enterRule(_localctx, 62, RULE_constantExpression);
try {
enterOuterAlt(_localctx, 1);
{
setState(407);
conditionalExpression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclarationContext extends ParserRuleContext {
public DeclarationSpecifiersContext declarationSpecifiers() {
return getRuleContext(DeclarationSpecifiersContext.class,0);
}
public TerminalNode Semi() { return getToken(CParser.Semi, 0); }
public InitDeclaratorListContext initDeclaratorList() {
return getRuleContext(InitDeclaratorListContext.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 CListener ) ((CListener)listener).enterDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final DeclarationContext declaration() throws RecognitionException {
DeclarationContext _localctx = new DeclarationContext(_ctx, getState());
enterRule(_localctx, 64, RULE_declaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(409);
declarationSpecifiers();
setState(411);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 60)) & ~0x3f) == 0 && ((1L << (_la - 60)) & ((1L << (LeftParen - 60)) | (1L << (Star - 60)) | (1L << (Caret - 60)) | (1L << (Identifier - 60)))) != 0)) {
{
setState(410);
initDeclaratorList();
}
}
setState(413);
match(Semi);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclarationSpecifiersContext extends ParserRuleContext {
public List declarationSpecifier() {
return getRuleContexts(DeclarationSpecifierContext.class);
}
public DeclarationSpecifierContext declarationSpecifier(int i) {
return getRuleContext(DeclarationSpecifierContext.class,i);
}
public DeclarationSpecifiersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declarationSpecifiers; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDeclarationSpecifiers(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDeclarationSpecifiers(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDeclarationSpecifiers(this);
else return visitor.visitChildren(this);
}
}
public final DeclarationSpecifiersContext declarationSpecifiers() throws RecognitionException {
DeclarationSpecifiersContext _localctx = new DeclarationSpecifiersContext(_ctx, getState());
enterRule(_localctx, 66, RULE_declarationSpecifiers);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(416);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(415);
declarationSpecifier();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(418);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,27,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclarationSpecifiers2Context extends ParserRuleContext {
public List declarationSpecifier() {
return getRuleContexts(DeclarationSpecifierContext.class);
}
public DeclarationSpecifierContext declarationSpecifier(int i) {
return getRuleContext(DeclarationSpecifierContext.class,i);
}
public DeclarationSpecifiers2Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declarationSpecifiers2; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDeclarationSpecifiers2(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDeclarationSpecifiers2(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDeclarationSpecifiers2(this);
else return visitor.visitChildren(this);
}
}
public final DeclarationSpecifiers2Context declarationSpecifiers2() throws RecognitionException {
DeclarationSpecifiers2Context _localctx = new DeclarationSpecifiers2Context(_ctx, getState());
enterRule(_localctx, 68, RULE_declarationSpecifiers2);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(421);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(420);
declarationSpecifier();
}
}
setState(423);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__11) | (1L << Extension) | (1L << Auto) | (1L << Char) | (1L << Const) | (1L << Double) | (1L << Enum) | (1L << Extern) | (1L << Float) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Register) | (1L << Restrict) | (1L << Short) | (1L << Signed) | (1L << Static) | (1L << Struct) | (1L << Typedef) | (1L << Union) | (1L << Unsigned) | (1L << Void) | (1L << Volatile) | (1L << Alignas) | (1L << Atomic) | (1L << Bool) | (1L << Complex) | (1L << Noreturn) | (1L << ThreadLocal))) != 0) || _la==Identifier );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CastDeclarationSpecifierListContext extends ParserRuleContext {
public CastDeclarationSpecifierContext castDeclarationSpecifier;
public List spec1 = new ArrayList();
public TypeSpecifierPointerContext spec2;
public List castDeclarationSpecifier() {
return getRuleContexts(CastDeclarationSpecifierContext.class);
}
public CastDeclarationSpecifierContext castDeclarationSpecifier(int i) {
return getRuleContext(CastDeclarationSpecifierContext.class,i);
}
public TypeSpecifierPointerContext typeSpecifierPointer() {
return getRuleContext(TypeSpecifierPointerContext.class,0);
}
public CastDeclarationSpecifierListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_castDeclarationSpecifierList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterCastDeclarationSpecifierList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitCastDeclarationSpecifierList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitCastDeclarationSpecifierList(this);
else return visitor.visitChildren(this);
}
}
public final CastDeclarationSpecifierListContext castDeclarationSpecifierList() throws RecognitionException {
CastDeclarationSpecifierListContext _localctx = new CastDeclarationSpecifierListContext(_ctx, getState());
enterRule(_localctx, 70, RULE_castDeclarationSpecifierList);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(428);
_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 ) {
{
{
setState(425);
((CastDeclarationSpecifierListContext)_localctx).castDeclarationSpecifier = castDeclarationSpecifier();
((CastDeclarationSpecifierListContext)_localctx).spec1.add(((CastDeclarationSpecifierListContext)_localctx).castDeclarationSpecifier);
}
}
}
setState(430);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,29,_ctx);
}
setState(432);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << Extension) | (1L << Char) | (1L << Double) | (1L << Enum) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << Short) | (1L << Signed) | (1L << Struct) | (1L << Union) | (1L << Unsigned) | (1L << Void) | (1L << Atomic) | (1L << Bool) | (1L << Complex))) != 0) || _la==Identifier) {
{
setState(431);
((CastDeclarationSpecifierListContext)_localctx).spec2 = typeSpecifierPointer();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class CastDeclarationSpecifierContext extends ParserRuleContext {
public StorageClassSpecifierContext storageClassSpecifier() {
return getRuleContext(StorageClassSpecifierContext.class,0);
}
public TypeSpecifierContext typeSpecifier() {
return getRuleContext(TypeSpecifierContext.class,0);
}
public TypeQualifierContext typeQualifier() {
return getRuleContext(TypeQualifierContext.class,0);
}
public FunctionSpecifierContext functionSpecifier() {
return getRuleContext(FunctionSpecifierContext.class,0);
}
public AlignmentSpecifierContext alignmentSpecifier() {
return getRuleContext(AlignmentSpecifierContext.class,0);
}
public CastDeclarationSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_castDeclarationSpecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterCastDeclarationSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitCastDeclarationSpecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitCastDeclarationSpecifier(this);
else return visitor.visitChildren(this);
}
}
public final CastDeclarationSpecifierContext castDeclarationSpecifier() throws RecognitionException {
CastDeclarationSpecifierContext _localctx = new CastDeclarationSpecifierContext(_ctx, getState());
enterRule(_localctx, 72, RULE_castDeclarationSpecifier);
try {
setState(439);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(434);
storageClassSpecifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(435);
typeSpecifier(0);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(436);
typeQualifier();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(437);
functionSpecifier();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(438);
alignmentSpecifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DeclarationSpecifierContext extends ParserRuleContext {
public StorageClassSpecifierContext storageClassSpecifier() {
return getRuleContext(StorageClassSpecifierContext.class,0);
}
public TypeSpecifierPointerContext typeSpecifierPointer() {
return getRuleContext(TypeSpecifierPointerContext.class,0);
}
public TypeSpecifierContext typeSpecifier() {
return getRuleContext(TypeSpecifierContext.class,0);
}
public TypeQualifierContext typeQualifier() {
return getRuleContext(TypeQualifierContext.class,0);
}
public FunctionSpecifierContext functionSpecifier() {
return getRuleContext(FunctionSpecifierContext.class,0);
}
public AlignmentSpecifierContext alignmentSpecifier() {
return getRuleContext(AlignmentSpecifierContext.class,0);
}
public DeclarationSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declarationSpecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDeclarationSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDeclarationSpecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDeclarationSpecifier(this);
else return visitor.visitChildren(this);
}
}
public final DeclarationSpecifierContext declarationSpecifier() throws RecognitionException {
DeclarationSpecifierContext _localctx = new DeclarationSpecifierContext(_ctx, getState());
enterRule(_localctx, 74, RULE_declarationSpecifier);
try {
setState(447);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,32,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(441);
storageClassSpecifier();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(442);
typeSpecifierPointer();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(443);
typeSpecifier(0);
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(444);
typeQualifier();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(445);
functionSpecifier();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(446);
alignmentSpecifier();
}
break;
}
}
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 List initDeclarator() {
return getRuleContexts(InitDeclaratorContext.class);
}
public InitDeclaratorContext initDeclarator(int i) {
return getRuleContext(InitDeclaratorContext.class,i);
}
public List Comma() { return getTokens(CParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(CParser.Comma, i);
}
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 CListener ) ((CListener)listener).enterInitDeclaratorList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitInitDeclaratorList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitInitDeclaratorList(this);
else return visitor.visitChildren(this);
}
}
public final InitDeclaratorListContext initDeclaratorList() throws RecognitionException {
InitDeclaratorListContext _localctx = new InitDeclaratorListContext(_ctx, getState());
enterRule(_localctx, 76, RULE_initDeclaratorList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(449);
initDeclarator();
setState(454);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Comma) {
{
{
setState(450);
match(Comma);
setState(451);
initDeclarator();
}
}
setState(456);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class InitDeclaratorContext extends ParserRuleContext {
public DeclaratorContext declarator() {
return getRuleContext(DeclaratorContext.class,0);
}
public TerminalNode Assign() { return getToken(CParser.Assign, 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 CListener ) ((CListener)listener).enterInitDeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitInitDeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitInitDeclarator(this);
else return visitor.visitChildren(this);
}
}
public final InitDeclaratorContext initDeclarator() throws RecognitionException {
InitDeclaratorContext _localctx = new InitDeclaratorContext(_ctx, getState());
enterRule(_localctx, 78, RULE_initDeclarator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(457);
declarator();
setState(460);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Assign) {
{
setState(458);
match(Assign);
setState(459);
initializer();
}
}
}
}
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 Typedef() { return getToken(CParser.Typedef, 0); }
public TerminalNode Extern() { return getToken(CParser.Extern, 0); }
public TerminalNode Static() { return getToken(CParser.Static, 0); }
public TerminalNode ThreadLocal() { return getToken(CParser.ThreadLocal, 0); }
public TerminalNode Auto() { return getToken(CParser.Auto, 0); }
public TerminalNode Register() { return getToken(CParser.Register, 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 CListener ) ((CListener)listener).enterStorageClassSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitStorageClassSpecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitStorageClassSpecifier(this);
else return visitor.visitChildren(this);
}
}
public final StorageClassSpecifierContext storageClassSpecifier() throws RecognitionException {
StorageClassSpecifierContext _localctx = new StorageClassSpecifierContext(_ctx, getState());
enterRule(_localctx, 80, RULE_storageClassSpecifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(462);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Auto) | (1L << Extern) | (1L << Register) | (1L << Static) | (1L << Typedef) | (1L << ThreadLocal))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeSpecifierContext extends ParserRuleContext {
public TypeSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeSpecifier; }
public TypeSpecifierContext() { }
public void copyFrom(TypeSpecifierContext ctx) {
super.copyFrom(ctx);
}
}
public static class TypeSpecifierEnumContext extends TypeSpecifierContext {
public EnumSpecifierContext enumSpecifier() {
return getRuleContext(EnumSpecifierContext.class,0);
}
public TypeSpecifierEnumContext(TypeSpecifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterTypeSpecifierEnum(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypeSpecifierEnum(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypeSpecifierEnum(this);
else return visitor.visitChildren(this);
}
}
public static class TypeSpecifierSimpleContext extends TypeSpecifierContext {
public TerminalNode Void() { return getToken(CParser.Void, 0); }
public TerminalNode Char() { return getToken(CParser.Char, 0); }
public TerminalNode Short() { return getToken(CParser.Short, 0); }
public TerminalNode Int() { return getToken(CParser.Int, 0); }
public TerminalNode Long() { return getToken(CParser.Long, 0); }
public TerminalNode Signed() { return getToken(CParser.Signed, 0); }
public TerminalNode Unsigned() { return getToken(CParser.Unsigned, 0); }
public TerminalNode Bool() { return getToken(CParser.Bool, 0); }
public TerminalNode Complex() { return getToken(CParser.Complex, 0); }
public TypeSpecifierSimpleContext(TypeSpecifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterTypeSpecifierSimple(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypeSpecifierSimple(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypeSpecifierSimple(this);
else return visitor.visitChildren(this);
}
}
public static class TypeSpecifierDoubleContext extends TypeSpecifierContext {
public TerminalNode Double() { return getToken(CParser.Double, 0); }
public TypeSpecifierDoubleContext(TypeSpecifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterTypeSpecifierDouble(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypeSpecifierDouble(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypeSpecifierDouble(this);
else return visitor.visitChildren(this);
}
}
public static class TypeSpecifierGccThreadContext extends TypeSpecifierContext {
public TypeSpecifierGccThreadContext(TypeSpecifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterTypeSpecifierGccThread(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypeSpecifierGccThread(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypeSpecifierGccThread(this);
else return visitor.visitChildren(this);
}
}
public static class TypeSpecifierCompoundContext extends TypeSpecifierContext {
public StructOrUnionSpecifierContext structOrUnionSpecifier() {
return getRuleContext(StructOrUnionSpecifierContext.class,0);
}
public TypeSpecifierCompoundContext(TypeSpecifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterTypeSpecifierCompound(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypeSpecifierCompound(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypeSpecifierCompound(this);
else return visitor.visitChildren(this);
}
}
public static class TypeSpecifierAtomicContext extends TypeSpecifierContext {
public AtomicTypeSpecifierContext atomicTypeSpecifier() {
return getRuleContext(AtomicTypeSpecifierContext.class,0);
}
public TypeSpecifierAtomicContext(TypeSpecifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterTypeSpecifierAtomic(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypeSpecifierAtomic(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypeSpecifierAtomic(this);
else return visitor.visitChildren(this);
}
}
public static class TypeSpecifierTypedefNameContext extends TypeSpecifierContext {
public TypedefNameContext typedefName() {
return getRuleContext(TypedefNameContext.class,0);
}
public TypeSpecifierTypedefNameContext(TypeSpecifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterTypeSpecifierTypedefName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypeSpecifierTypedefName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypeSpecifierTypedefName(this);
else return visitor.visitChildren(this);
}
}
public static class TypeSpecifierFloatContext extends TypeSpecifierContext {
public TerminalNode Float() { return getToken(CParser.Float, 0); }
public TypeSpecifierFloatContext(TypeSpecifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterTypeSpecifierFloat(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypeSpecifierFloat(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypeSpecifierFloat(this);
else return visitor.visitChildren(this);
}
}
public static class TypeSpecifierTypeofContext extends TypeSpecifierContext {
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public ConstantExpressionContext constantExpression() {
return getRuleContext(ConstantExpressionContext.class,0);
}
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public TypeSpecifierTypeofContext(TypeSpecifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterTypeSpecifierTypeof(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypeSpecifierTypeof(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypeSpecifierTypeof(this);
else return visitor.visitChildren(this);
}
}
public static class TypeSpecifierFunctionPointerContext extends TypeSpecifierContext {
public TypeSpecifierContext typeSpecifier() {
return getRuleContext(TypeSpecifierContext.class,0);
}
public List LeftParen() { return getTokens(CParser.LeftParen); }
public TerminalNode LeftParen(int i) {
return getToken(CParser.LeftParen, i);
}
public TerminalNode Star() { return getToken(CParser.Star, 0); }
public List RightParen() { return getTokens(CParser.RightParen); }
public TerminalNode RightParen(int i) {
return getToken(CParser.RightParen, i);
}
public ParameterTypeListContext parameterTypeList() {
return getRuleContext(ParameterTypeListContext.class,0);
}
public TypeSpecifierFunctionPointerContext(TypeSpecifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterTypeSpecifierFunctionPointer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypeSpecifierFunctionPointer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypeSpecifierFunctionPointer(this);
else return visitor.visitChildren(this);
}
}
public static class TypeSpecifierExtensionContext extends TypeSpecifierContext {
public TerminalNode Extension() { return getToken(CParser.Extension, 0); }
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public TypeSpecifierExtensionContext(TypeSpecifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterTypeSpecifierExtension(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypeSpecifierExtension(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypeSpecifierExtension(this);
else return visitor.visitChildren(this);
}
}
public final TypeSpecifierContext typeSpecifier() throws RecognitionException {
return typeSpecifier(0);
}
private TypeSpecifierContext typeSpecifier(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
TypeSpecifierContext _localctx = new TypeSpecifierContext(_ctx, _parentState);
TypeSpecifierContext _prevctx = _localctx;
int _startState = 82;
enterRecursionRule(_localctx, 82, RULE_typeSpecifier, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(482);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case T__1:
case T__2:
case T__3:
case Char:
case Int:
case Long:
case Short:
case Signed:
case Unsigned:
case Void:
case Bool:
case Complex:
{
_localctx = new TypeSpecifierSimpleContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(465);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << Char) | (1L << Int) | (1L << Long) | (1L << Short) | (1L << Signed) | (1L << Unsigned) | (1L << Void) | (1L << Bool) | (1L << Complex))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case T__4:
{
_localctx = new TypeSpecifierGccThreadContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(466);
match(T__4);
}
break;
case Float:
{
_localctx = new TypeSpecifierFloatContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(467);
match(Float);
}
break;
case Double:
{
_localctx = new TypeSpecifierDoubleContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(468);
match(Double);
}
break;
case Extension:
{
_localctx = new TypeSpecifierExtensionContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(469);
match(Extension);
setState(470);
match(LeftParen);
setState(471);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__1) | (1L << T__2) | (1L << T__3))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(472);
match(RightParen);
}
break;
case Atomic:
{
_localctx = new TypeSpecifierAtomicContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(473);
atomicTypeSpecifier();
}
break;
case Struct:
case Union:
{
_localctx = new TypeSpecifierCompoundContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(474);
structOrUnionSpecifier();
}
break;
case Enum:
{
_localctx = new TypeSpecifierEnumContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(475);
enumSpecifier();
}
break;
case Identifier:
{
_localctx = new TypeSpecifierTypedefNameContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(476);
typedefName();
}
break;
case T__5:
{
_localctx = new TypeSpecifierTypeofContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(477);
match(T__5);
setState(478);
match(LeftParen);
setState(479);
constantExpression();
setState(480);
match(RightParen);
}
break;
default:
throw new NoViableAltException(this);
}
_ctx.stop = _input.LT(-1);
setState(495);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,37,_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 TypeSpecifierFunctionPointerContext(new TypeSpecifierContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_typeSpecifier);
setState(484);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(485);
match(LeftParen);
setState(486);
match(Star);
setState(487);
match(RightParen);
setState(488);
match(LeftParen);
setState(490);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__11) | (1L << Extension) | (1L << Auto) | (1L << Char) | (1L << Const) | (1L << Double) | (1L << Enum) | (1L << Extern) | (1L << Float) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Register) | (1L << Restrict) | (1L << Short) | (1L << Signed) | (1L << Static) | (1L << Struct) | (1L << Typedef) | (1L << Union) | (1L << Unsigned) | (1L << Void) | (1L << Volatile) | (1L << Alignas) | (1L << Atomic) | (1L << Bool) | (1L << Complex) | (1L << Noreturn) | (1L << ThreadLocal))) != 0) || _la==Identifier) {
{
setState(489);
parameterTypeList();
}
}
setState(492);
match(RightParen);
}
}
}
setState(497);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,37,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class TypeSpecifierPointerContext extends ParserRuleContext {
public TypeSpecifierContext typeSpecifier() {
return getRuleContext(TypeSpecifierContext.class,0);
}
public PointerContext pointer() {
return getRuleContext(PointerContext.class,0);
}
public TypeSpecifierPointerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeSpecifierPointer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterTypeSpecifierPointer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypeSpecifierPointer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypeSpecifierPointer(this);
else return visitor.visitChildren(this);
}
}
public final TypeSpecifierPointerContext typeSpecifierPointer() throws RecognitionException {
TypeSpecifierPointerContext _localctx = new TypeSpecifierPointerContext(_ctx, getState());
enterRule(_localctx, 84, RULE_typeSpecifierPointer);
try {
enterOuterAlt(_localctx, 1);
{
setState(498);
typeSpecifier(0);
setState(499);
pointer();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StructOrUnionSpecifierContext extends ParserRuleContext {
public StructOrUnionSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structOrUnionSpecifier; }
public StructOrUnionSpecifierContext() { }
public void copyFrom(StructOrUnionSpecifierContext ctx) {
super.copyFrom(ctx);
}
}
public static class CompoundDefinitionContext extends StructOrUnionSpecifierContext {
public StructOrUnionContext structOrUnion() {
return getRuleContext(StructOrUnionContext.class,0);
}
public TerminalNode LeftBrace() { return getToken(CParser.LeftBrace, 0); }
public StructDeclarationListContext structDeclarationList() {
return getRuleContext(StructDeclarationListContext.class,0);
}
public TerminalNode RightBrace() { return getToken(CParser.RightBrace, 0); }
public TerminalNode Identifier() { return getToken(CParser.Identifier, 0); }
public CompoundDefinitionContext(StructOrUnionSpecifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterCompoundDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitCompoundDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitCompoundDefinition(this);
else return visitor.visitChildren(this);
}
}
public static class CompoundUsageContext extends StructOrUnionSpecifierContext {
public StructOrUnionContext structOrUnion() {
return getRuleContext(StructOrUnionContext.class,0);
}
public TerminalNode Identifier() { return getToken(CParser.Identifier, 0); }
public CompoundUsageContext(StructOrUnionSpecifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterCompoundUsage(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitCompoundUsage(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitCompoundUsage(this);
else return visitor.visitChildren(this);
}
}
public final StructOrUnionSpecifierContext structOrUnionSpecifier() throws RecognitionException {
StructOrUnionSpecifierContext _localctx = new StructOrUnionSpecifierContext(_ctx, getState());
enterRule(_localctx, 86, RULE_structOrUnionSpecifier);
int _la;
try {
setState(512);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
case 1:
_localctx = new CompoundDefinitionContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(501);
structOrUnion();
setState(503);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Identifier) {
{
setState(502);
match(Identifier);
}
}
setState(505);
match(LeftBrace);
setState(506);
structDeclarationList();
setState(507);
match(RightBrace);
}
break;
case 2:
_localctx = new CompoundUsageContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(509);
structOrUnion();
setState(510);
match(Identifier);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StructOrUnionContext extends ParserRuleContext {
public TerminalNode Struct() { return getToken(CParser.Struct, 0); }
public TerminalNode Union() { return getToken(CParser.Union, 0); }
public StructOrUnionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structOrUnion; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterStructOrUnion(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitStructOrUnion(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitStructOrUnion(this);
else return visitor.visitChildren(this);
}
}
public final StructOrUnionContext structOrUnion() throws RecognitionException {
StructOrUnionContext _localctx = new StructOrUnionContext(_ctx, getState());
enterRule(_localctx, 88, RULE_structOrUnion);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(514);
_la = _input.LA(1);
if ( !(_la==Struct || _la==Union) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StructDeclarationListContext extends ParserRuleContext {
public List structDeclaration() {
return getRuleContexts(StructDeclarationContext.class);
}
public StructDeclarationContext structDeclaration(int i) {
return getRuleContext(StructDeclarationContext.class,i);
}
public StructDeclarationListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structDeclarationList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterStructDeclarationList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitStructDeclarationList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitStructDeclarationList(this);
else return visitor.visitChildren(this);
}
}
public final StructDeclarationListContext structDeclarationList() throws RecognitionException {
StructDeclarationListContext _localctx = new StructDeclarationListContext(_ctx, getState());
enterRule(_localctx, 90, RULE_structDeclarationList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(517);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(516);
structDeclaration();
}
}
setState(519);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << Extension) | (1L << Char) | (1L << Const) | (1L << Double) | (1L << Enum) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << Restrict) | (1L << Short) | (1L << Signed) | (1L << Struct) | (1L << Union) | (1L << Unsigned) | (1L << Void) | (1L << Volatile) | (1L << Atomic) | (1L << Bool) | (1L << Complex))) != 0) || _la==Identifier );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StructDeclarationContext extends ParserRuleContext {
public SpecifierQualifierListContext specifierQualifierList() {
return getRuleContext(SpecifierQualifierListContext.class,0);
}
public TerminalNode Semi() { return getToken(CParser.Semi, 0); }
public StructDeclaratorListContext structDeclaratorList() {
return getRuleContext(StructDeclaratorListContext.class,0);
}
public StructDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterStructDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitStructDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitStructDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final StructDeclarationContext structDeclaration() throws RecognitionException {
StructDeclarationContext _localctx = new StructDeclarationContext(_ctx, getState());
enterRule(_localctx, 92, RULE_structDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(521);
specifierQualifierList();
setState(523);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 60)) & ~0x3f) == 0 && ((1L << (_la - 60)) & ((1L << (LeftParen - 60)) | (1L << (Star - 60)) | (1L << (Caret - 60)) | (1L << (Colon - 60)) | (1L << (Identifier - 60)))) != 0)) {
{
setState(522);
structDeclaratorList();
}
}
setState(525);
match(Semi);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SpecifierQualifierListContext extends ParserRuleContext {
public TypeSpecifierPointerContext typeSpecifierPointer() {
return getRuleContext(TypeSpecifierPointerContext.class,0);
}
public List typeSpecifierOrQualifier() {
return getRuleContexts(TypeSpecifierOrQualifierContext.class);
}
public TypeSpecifierOrQualifierContext typeSpecifierOrQualifier(int i) {
return getRuleContext(TypeSpecifierOrQualifierContext.class,i);
}
public SpecifierQualifierListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_specifierQualifierList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterSpecifierQualifierList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitSpecifierQualifierList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitSpecifierQualifierList(this);
else return visitor.visitChildren(this);
}
}
public final SpecifierQualifierListContext specifierQualifierList() throws RecognitionException {
SpecifierQualifierListContext _localctx = new SpecifierQualifierListContext(_ctx, getState());
enterRule(_localctx, 94, RULE_specifierQualifierList);
try {
int _alt;
setState(539);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(528);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(527);
typeSpecifierOrQualifier();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(530);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,42,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
setState(532);
typeSpecifierPointer();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(535);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(534);
typeSpecifierOrQualifier();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(537);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,43,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeSpecifierOrQualifierContext extends ParserRuleContext {
public TypeSpecifierContext typeSpecifier() {
return getRuleContext(TypeSpecifierContext.class,0);
}
public TypeQualifierContext typeQualifier() {
return getRuleContext(TypeQualifierContext.class,0);
}
public TypeSpecifierOrQualifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeSpecifierOrQualifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterTypeSpecifierOrQualifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypeSpecifierOrQualifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypeSpecifierOrQualifier(this);
else return visitor.visitChildren(this);
}
}
public final TypeSpecifierOrQualifierContext typeSpecifierOrQualifier() throws RecognitionException {
TypeSpecifierOrQualifierContext _localctx = new TypeSpecifierOrQualifierContext(_ctx, getState());
enterRule(_localctx, 96, RULE_typeSpecifierOrQualifier);
try {
setState(543);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(541);
typeSpecifier(0);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(542);
typeQualifier();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StructDeclaratorListContext extends ParserRuleContext {
public List structDeclarator() {
return getRuleContexts(StructDeclaratorContext.class);
}
public StructDeclaratorContext structDeclarator(int i) {
return getRuleContext(StructDeclaratorContext.class,i);
}
public List Comma() { return getTokens(CParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(CParser.Comma, i);
}
public StructDeclaratorListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structDeclaratorList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterStructDeclaratorList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitStructDeclaratorList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitStructDeclaratorList(this);
else return visitor.visitChildren(this);
}
}
public final StructDeclaratorListContext structDeclaratorList() throws RecognitionException {
StructDeclaratorListContext _localctx = new StructDeclaratorListContext(_ctx, getState());
enterRule(_localctx, 98, RULE_structDeclaratorList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(545);
structDeclarator();
setState(550);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Comma) {
{
{
setState(546);
match(Comma);
setState(547);
structDeclarator();
}
}
setState(552);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class StructDeclaratorContext extends ParserRuleContext {
public StructDeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_structDeclarator; }
public StructDeclaratorContext() { }
public void copyFrom(StructDeclaratorContext ctx) {
super.copyFrom(ctx);
}
}
public static class StructDeclaratorConstantContext extends StructDeclaratorContext {
public TerminalNode Colon() { return getToken(CParser.Colon, 0); }
public ConstantExpressionContext constantExpression() {
return getRuleContext(ConstantExpressionContext.class,0);
}
public DeclaratorContext declarator() {
return getRuleContext(DeclaratorContext.class,0);
}
public StructDeclaratorConstantContext(StructDeclaratorContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterStructDeclaratorConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitStructDeclaratorConstant(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitStructDeclaratorConstant(this);
else return visitor.visitChildren(this);
}
}
public static class StructDeclaratorSimpleContext extends StructDeclaratorContext {
public DeclaratorContext declarator() {
return getRuleContext(DeclaratorContext.class,0);
}
public StructDeclaratorSimpleContext(StructDeclaratorContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterStructDeclaratorSimple(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitStructDeclaratorSimple(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitStructDeclaratorSimple(this);
else return visitor.visitChildren(this);
}
}
public final StructDeclaratorContext structDeclarator() throws RecognitionException {
StructDeclaratorContext _localctx = new StructDeclaratorContext(_ctx, getState());
enterRule(_localctx, 100, RULE_structDeclarator);
int _la;
try {
setState(559);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
case 1:
_localctx = new StructDeclaratorSimpleContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(553);
declarator();
}
break;
case 2:
_localctx = new StructDeclaratorConstantContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(555);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 60)) & ~0x3f) == 0 && ((1L << (_la - 60)) & ((1L << (LeftParen - 60)) | (1L << (Star - 60)) | (1L << (Caret - 60)) | (1L << (Identifier - 60)))) != 0)) {
{
setState(554);
declarator();
}
}
setState(557);
match(Colon);
setState(558);
constantExpression();
}
break;
}
}
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 EnumSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumSpecifier; }
public EnumSpecifierContext() { }
public void copyFrom(EnumSpecifierContext ctx) {
super.copyFrom(ctx);
}
}
public static class EnumDefinitionContext extends EnumSpecifierContext {
public TerminalNode Enum() { return getToken(CParser.Enum, 0); }
public TerminalNode LeftBrace() { return getToken(CParser.LeftBrace, 0); }
public EnumeratorListContext enumeratorList() {
return getRuleContext(EnumeratorListContext.class,0);
}
public TerminalNode RightBrace() { return getToken(CParser.RightBrace, 0); }
public TerminalNode Identifier() { return getToken(CParser.Identifier, 0); }
public TerminalNode Comma() { return getToken(CParser.Comma, 0); }
public EnumDefinitionContext(EnumSpecifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterEnumDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitEnumDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitEnumDefinition(this);
else return visitor.visitChildren(this);
}
}
public static class EnumUsageContext extends EnumSpecifierContext {
public TerminalNode Enum() { return getToken(CParser.Enum, 0); }
public TerminalNode Identifier() { return getToken(CParser.Identifier, 0); }
public EnumUsageContext(EnumSpecifierContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterEnumUsage(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitEnumUsage(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitEnumUsage(this);
else return visitor.visitChildren(this);
}
}
public final EnumSpecifierContext enumSpecifier() throws RecognitionException {
EnumSpecifierContext _localctx = new EnumSpecifierContext(_ctx, getState());
enterRule(_localctx, 102, RULE_enumSpecifier);
int _la;
try {
setState(574);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) {
case 1:
_localctx = new EnumDefinitionContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(561);
match(Enum);
setState(563);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Identifier) {
{
setState(562);
match(Identifier);
}
}
setState(565);
match(LeftBrace);
setState(566);
enumeratorList();
setState(568);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Comma) {
{
setState(567);
match(Comma);
}
}
setState(570);
match(RightBrace);
}
break;
case 2:
_localctx = new EnumUsageContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(572);
match(Enum);
setState(573);
match(Identifier);
}
break;
}
}
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 List enumerator() {
return getRuleContexts(EnumeratorContext.class);
}
public EnumeratorContext enumerator(int i) {
return getRuleContext(EnumeratorContext.class,i);
}
public List Comma() { return getTokens(CParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(CParser.Comma, i);
}
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 CListener ) ((CListener)listener).enterEnumeratorList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitEnumeratorList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitEnumeratorList(this);
else return visitor.visitChildren(this);
}
}
public final EnumeratorListContext enumeratorList() throws RecognitionException {
EnumeratorListContext _localctx = new EnumeratorListContext(_ctx, getState());
enterRule(_localctx, 104, RULE_enumeratorList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(576);
enumerator();
setState(581);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,52,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(577);
match(Comma);
setState(578);
enumerator();
}
}
}
setState(583);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,52,_ctx);
}
}
}
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 EnumerationConstantContext enumerationConstant() {
return getRuleContext(EnumerationConstantContext.class,0);
}
public TerminalNode Assign() { return getToken(CParser.Assign, 0); }
public ConstantExpressionContext constantExpression() {
return getRuleContext(ConstantExpressionContext.class,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 CListener ) ((CListener)listener).enterEnumerator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitEnumerator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitEnumerator(this);
else return visitor.visitChildren(this);
}
}
public final EnumeratorContext enumerator() throws RecognitionException {
EnumeratorContext _localctx = new EnumeratorContext(_ctx, getState());
enterRule(_localctx, 106, RULE_enumerator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(584);
enumerationConstant();
setState(587);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Assign) {
{
setState(585);
match(Assign);
setState(586);
constantExpression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class EnumerationConstantContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CParser.Identifier, 0); }
public EnumerationConstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_enumerationConstant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterEnumerationConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitEnumerationConstant(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitEnumerationConstant(this);
else return visitor.visitChildren(this);
}
}
public final EnumerationConstantContext enumerationConstant() throws RecognitionException {
EnumerationConstantContext _localctx = new EnumerationConstantContext(_ctx, getState());
enterRule(_localctx, 108, RULE_enumerationConstant);
try {
enterOuterAlt(_localctx, 1);
{
setState(589);
match(Identifier);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class AtomicTypeSpecifierContext extends ParserRuleContext {
public TerminalNode Atomic() { return getToken(CParser.Atomic, 0); }
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.class,0);
}
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public AtomicTypeSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_atomicTypeSpecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterAtomicTypeSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitAtomicTypeSpecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitAtomicTypeSpecifier(this);
else return visitor.visitChildren(this);
}
}
public final AtomicTypeSpecifierContext atomicTypeSpecifier() throws RecognitionException {
AtomicTypeSpecifierContext _localctx = new AtomicTypeSpecifierContext(_ctx, getState());
enterRule(_localctx, 110, RULE_atomicTypeSpecifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(591);
match(Atomic);
setState(592);
match(LeftParen);
setState(593);
typeName();
setState(594);
match(RightParen);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeQualifierContext extends ParserRuleContext {
public TerminalNode Const() { return getToken(CParser.Const, 0); }
public TerminalNode Restrict() { return getToken(CParser.Restrict, 0); }
public TerminalNode Volatile() { return getToken(CParser.Volatile, 0); }
public TerminalNode Atomic() { return getToken(CParser.Atomic, 0); }
public TypeQualifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeQualifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterTypeQualifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypeQualifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypeQualifier(this);
else return visitor.visitChildren(this);
}
}
public final TypeQualifierContext typeQualifier() throws RecognitionException {
TypeQualifierContext _localctx = new TypeQualifierContext(_ctx, getState());
enterRule(_localctx, 112, RULE_typeQualifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(596);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Const) | (1L << Restrict) | (1L << Volatile) | (1L << Atomic))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class FunctionSpecifierContext extends ParserRuleContext {
public TerminalNode Inline() { return getToken(CParser.Inline, 0); }
public TerminalNode Noreturn() { return getToken(CParser.Noreturn, 0); }
public GccAttributeSpecifierContext gccAttributeSpecifier() {
return getRuleContext(GccAttributeSpecifierContext.class,0);
}
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public TerminalNode Identifier() { return getToken(CParser.Identifier, 0); }
public TerminalNode RightParen() { return getToken(CParser.RightParen, 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 CListener ) ((CListener)listener).enterFunctionSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitFunctionSpecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitFunctionSpecifier(this);
else return visitor.visitChildren(this);
}
}
public final FunctionSpecifierContext functionSpecifier() throws RecognitionException {
FunctionSpecifierContext _localctx = new FunctionSpecifierContext(_ctx, getState());
enterRule(_localctx, 114, RULE_functionSpecifier);
int _la;
try {
setState(604);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__6:
case T__7:
case Inline:
case Noreturn:
enterOuterAlt(_localctx, 1);
{
setState(598);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__6) | (1L << T__7) | (1L << Inline) | (1L << Noreturn))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case T__11:
enterOuterAlt(_localctx, 2);
{
setState(599);
gccAttributeSpecifier();
}
break;
case T__8:
enterOuterAlt(_localctx, 3);
{
setState(600);
match(T__8);
setState(601);
match(LeftParen);
setState(602);
match(Identifier);
setState(603);
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 AlignmentSpecifierContext extends ParserRuleContext {
public TerminalNode Alignas() { return getToken(CParser.Alignas, 0); }
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public TypeNameContext typeName() {
return getRuleContext(TypeNameContext.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 CListener ) ((CListener)listener).enterAlignmentSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitAlignmentSpecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitAlignmentSpecifier(this);
else return visitor.visitChildren(this);
}
}
public final AlignmentSpecifierContext alignmentSpecifier() throws RecognitionException {
AlignmentSpecifierContext _localctx = new AlignmentSpecifierContext(_ctx, getState());
enterRule(_localctx, 116, RULE_alignmentSpecifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(606);
match(Alignas);
setState(607);
match(LeftParen);
setState(610);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) {
case 1:
{
setState(608);
typeName();
}
break;
case 2:
{
setState(609);
constantExpression();
}
break;
}
setState(612);
match(RightParen);
}
}
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 DirectDeclaratorContext directDeclarator() {
return getRuleContext(DirectDeclaratorContext.class,0);
}
public PointerContext pointer() {
return getRuleContext(PointerContext.class,0);
}
public List gccDeclaratorExtension() {
return getRuleContexts(GccDeclaratorExtensionContext.class);
}
public GccDeclaratorExtensionContext gccDeclaratorExtension(int i) {
return getRuleContext(GccDeclaratorExtensionContext.class,i);
}
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 CListener ) ((CListener)listener).enterDeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDeclarator(this);
else return visitor.visitChildren(this);
}
}
public final DeclaratorContext declarator() throws RecognitionException {
DeclaratorContext _localctx = new DeclaratorContext(_ctx, getState());
enterRule(_localctx, 118, RULE_declarator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(615);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Star || _la==Caret) {
{
setState(614);
pointer();
}
}
setState(617);
directDeclarator(0);
setState(621);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__9) | (1L << T__10) | (1L << T__11))) != 0)) {
{
{
setState(618);
gccDeclaratorExtension();
}
}
setState(623);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DirectDeclaratorContext extends ParserRuleContext {
public DirectDeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_directDeclarator; }
public DirectDeclaratorContext() { }
public void copyFrom(DirectDeclaratorContext ctx) {
super.copyFrom(ctx);
}
}
public static class DirectDeclaratorIdContext extends DirectDeclaratorContext {
public TerminalNode Identifier() { return getToken(CParser.Identifier, 0); }
public DirectDeclaratorIdContext(DirectDeclaratorContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDirectDeclaratorId(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDirectDeclaratorId(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDirectDeclaratorId(this);
else return visitor.visitChildren(this);
}
}
public static class DirectDeclaratorBracesContext extends DirectDeclaratorContext {
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public DeclaratorContext declarator() {
return getRuleContext(DeclaratorContext.class,0);
}
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public DirectDeclaratorBracesContext(DirectDeclaratorContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDirectDeclaratorBraces(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDirectDeclaratorBraces(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDirectDeclaratorBraces(this);
else return visitor.visitChildren(this);
}
}
public static class DirectDeclaratorBitFieldContext extends DirectDeclaratorContext {
public TerminalNode Identifier() { return getToken(CParser.Identifier, 0); }
public TerminalNode Colon() { return getToken(CParser.Colon, 0); }
public TerminalNode DigitSequence() { return getToken(CParser.DigitSequence, 0); }
public DirectDeclaratorBitFieldContext(DirectDeclaratorContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDirectDeclaratorBitField(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDirectDeclaratorBitField(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDirectDeclaratorBitField(this);
else return visitor.visitChildren(this);
}
}
public static class DirectDeclaratorArray4Context extends DirectDeclaratorContext {
public DirectDeclaratorContext directDeclarator() {
return getRuleContext(DirectDeclaratorContext.class,0);
}
public TerminalNode LeftBracket() { return getToken(CParser.LeftBracket, 0); }
public TerminalNode Star() { return getToken(CParser.Star, 0); }
public TerminalNode RightBracket() { return getToken(CParser.RightBracket, 0); }
public TypeQualifierListContext typeQualifierList() {
return getRuleContext(TypeQualifierListContext.class,0);
}
public DirectDeclaratorArray4Context(DirectDeclaratorContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDirectDeclaratorArray4(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDirectDeclaratorArray4(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDirectDeclaratorArray4(this);
else return visitor.visitChildren(this);
}
}
public static class DirectDeclaratorArray3Context extends DirectDeclaratorContext {
public DirectDeclaratorContext directDeclarator() {
return getRuleContext(DirectDeclaratorContext.class,0);
}
public TerminalNode LeftBracket() { return getToken(CParser.LeftBracket, 0); }
public TypeQualifierListContext typeQualifierList() {
return getRuleContext(TypeQualifierListContext.class,0);
}
public TerminalNode Static() { return getToken(CParser.Static, 0); }
public AssignmentExpressionContext assignmentExpression() {
return getRuleContext(AssignmentExpressionContext.class,0);
}
public TerminalNode RightBracket() { return getToken(CParser.RightBracket, 0); }
public DirectDeclaratorArray3Context(DirectDeclaratorContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDirectDeclaratorArray3(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDirectDeclaratorArray3(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDirectDeclaratorArray3(this);
else return visitor.visitChildren(this);
}
}
public static class DirectDeclaratorArray2Context extends DirectDeclaratorContext {
public DirectDeclaratorContext directDeclarator() {
return getRuleContext(DirectDeclaratorContext.class,0);
}
public TerminalNode LeftBracket() { return getToken(CParser.LeftBracket, 0); }
public TerminalNode Static() { return getToken(CParser.Static, 0); }
public AssignmentExpressionContext assignmentExpression() {
return getRuleContext(AssignmentExpressionContext.class,0);
}
public TerminalNode RightBracket() { return getToken(CParser.RightBracket, 0); }
public TypeQualifierListContext typeQualifierList() {
return getRuleContext(TypeQualifierListContext.class,0);
}
public DirectDeclaratorArray2Context(DirectDeclaratorContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDirectDeclaratorArray2(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDirectDeclaratorArray2(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDirectDeclaratorArray2(this);
else return visitor.visitChildren(this);
}
}
public static class DirectDeclaratorArray1Context extends DirectDeclaratorContext {
public DirectDeclaratorContext directDeclarator() {
return getRuleContext(DirectDeclaratorContext.class,0);
}
public TerminalNode LeftBracket() { return getToken(CParser.LeftBracket, 0); }
public TerminalNode RightBracket() { return getToken(CParser.RightBracket, 0); }
public TypeQualifierListContext typeQualifierList() {
return getRuleContext(TypeQualifierListContext.class,0);
}
public AssignmentExpressionContext assignmentExpression() {
return getRuleContext(AssignmentExpressionContext.class,0);
}
public DirectDeclaratorArray1Context(DirectDeclaratorContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDirectDeclaratorArray1(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDirectDeclaratorArray1(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDirectDeclaratorArray1(this);
else return visitor.visitChildren(this);
}
}
public static class DirectDeclaratorFunctionDeclContext extends DirectDeclaratorContext {
public DirectDeclaratorContext directDeclarator() {
return getRuleContext(DirectDeclaratorContext.class,0);
}
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public ParameterTypeListContext parameterTypeList() {
return getRuleContext(ParameterTypeListContext.class,0);
}
public DirectDeclaratorFunctionDeclContext(DirectDeclaratorContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDirectDeclaratorFunctionDecl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDirectDeclaratorFunctionDecl(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDirectDeclaratorFunctionDecl(this);
else return visitor.visitChildren(this);
}
}
public final DirectDeclaratorContext directDeclarator() throws RecognitionException {
return directDeclarator(0);
}
private DirectDeclaratorContext directDeclarator(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
DirectDeclaratorContext _localctx = new DirectDeclaratorContext(_ctx, _parentState);
DirectDeclaratorContext _prevctx = _localctx;
int _startState = 120;
enterRecursionRule(_localctx, 120, RULE_directDeclarator, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(633);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,58,_ctx) ) {
case 1:
{
_localctx = new DirectDeclaratorIdContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(625);
match(Identifier);
}
break;
case 2:
{
_localctx = new DirectDeclaratorBracesContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(626);
match(LeftParen);
setState(627);
declarator();
setState(628);
match(RightParen);
}
break;
case 3:
{
_localctx = new DirectDeclaratorBitFieldContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(630);
match(Identifier);
setState(631);
match(Colon);
setState(632);
match(DigitSequence);
}
break;
}
_ctx.stop = _input.LT(-1);
setState(675);
_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;
{
setState(673);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,64,_ctx) ) {
case 1:
{
_localctx = new DirectDeclaratorArray1Context(new DirectDeclaratorContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_directDeclarator);
setState(635);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(636);
match(LeftBracket);
setState(638);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Const) | (1L << Restrict) | (1L << Volatile) | (1L << Atomic))) != 0)) {
{
setState(637);
typeQualifierList();
}
}
setState(641);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRETTY_FUNC) | (1L << Extension) | (1L << Sizeof) | (1L << Alignof) | (1L << LeftParen))) != 0) || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (Plus - 72)) | (1L << (PlusPlus - 72)) | (1L << (Minus - 72)) | (1L << (MinusMinus - 72)) | (1L << (Star - 72)) | (1L << (And - 72)) | (1L << (Not - 72)) | (1L << (Tilde - 72)) | (1L << (Identifier - 72)) | (1L << (Constant - 72)) | (1L << (StringLiteral - 72)))) != 0)) {
{
setState(640);
assignmentExpression();
}
}
setState(643);
match(RightBracket);
}
break;
case 2:
{
_localctx = new DirectDeclaratorArray2Context(new DirectDeclaratorContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_directDeclarator);
setState(644);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(645);
match(LeftBracket);
setState(646);
match(Static);
setState(648);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Const) | (1L << Restrict) | (1L << Volatile) | (1L << Atomic))) != 0)) {
{
setState(647);
typeQualifierList();
}
}
setState(650);
assignmentExpression();
setState(651);
match(RightBracket);
}
break;
case 3:
{
_localctx = new DirectDeclaratorArray3Context(new DirectDeclaratorContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_directDeclarator);
setState(653);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(654);
match(LeftBracket);
setState(655);
typeQualifierList();
setState(656);
match(Static);
setState(657);
assignmentExpression();
setState(658);
match(RightBracket);
}
break;
case 4:
{
_localctx = new DirectDeclaratorArray4Context(new DirectDeclaratorContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_directDeclarator);
setState(660);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(661);
match(LeftBracket);
setState(663);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Const) | (1L << Restrict) | (1L << Volatile) | (1L << Atomic))) != 0)) {
{
setState(662);
typeQualifierList();
}
}
setState(665);
match(Star);
setState(666);
match(RightBracket);
}
break;
case 5:
{
_localctx = new DirectDeclaratorFunctionDeclContext(new DirectDeclaratorContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_directDeclarator);
setState(667);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(668);
match(LeftParen);
setState(670);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__11) | (1L << Extension) | (1L << Auto) | (1L << Char) | (1L << Const) | (1L << Double) | (1L << Enum) | (1L << Extern) | (1L << Float) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Register) | (1L << Restrict) | (1L << Short) | (1L << Signed) | (1L << Static) | (1L << Struct) | (1L << Typedef) | (1L << Union) | (1L << Unsigned) | (1L << Void) | (1L << Volatile) | (1L << Alignas) | (1L << Atomic) | (1L << Bool) | (1L << Complex) | (1L << Noreturn) | (1L << ThreadLocal))) != 0) || _la==Identifier) {
{
setState(669);
parameterTypeList();
}
}
setState(672);
match(RightParen);
}
break;
}
}
}
setState(677);
_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 GccDeclaratorExtensionContext extends ParserRuleContext {
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public List StringLiteral() { return getTokens(CParser.StringLiteral); }
public TerminalNode StringLiteral(int i) {
return getToken(CParser.StringLiteral, i);
}
public GccAttributeSpecifierContext gccAttributeSpecifier() {
return getRuleContext(GccAttributeSpecifierContext.class,0);
}
public GccDeclaratorExtensionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gccDeclaratorExtension; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterGccDeclaratorExtension(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitGccDeclaratorExtension(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitGccDeclaratorExtension(this);
else return visitor.visitChildren(this);
}
}
public final GccDeclaratorExtensionContext gccDeclaratorExtension() throws RecognitionException {
GccDeclaratorExtensionContext _localctx = new GccDeclaratorExtensionContext(_ctx, getState());
enterRule(_localctx, 122, RULE_gccDeclaratorExtension);
int _la;
try {
setState(687);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__9:
case T__10:
enterOuterAlt(_localctx, 1);
{
setState(678);
_la = _input.LA(1);
if ( !(_la==T__9 || _la==T__10) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(679);
match(LeftParen);
setState(681);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(680);
match(StringLiteral);
}
}
setState(683);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==StringLiteral );
setState(685);
match(RightParen);
}
break;
case T__11:
enterOuterAlt(_localctx, 2);
{
setState(686);
gccAttributeSpecifier();
}
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 GccAttributeSpecifierContext extends ParserRuleContext {
public List LeftParen() { return getTokens(CParser.LeftParen); }
public TerminalNode LeftParen(int i) {
return getToken(CParser.LeftParen, i);
}
public GccAttributeListContext gccAttributeList() {
return getRuleContext(GccAttributeListContext.class,0);
}
public List RightParen() { return getTokens(CParser.RightParen); }
public TerminalNode RightParen(int i) {
return getToken(CParser.RightParen, i);
}
public GccAttributeSpecifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gccAttributeSpecifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterGccAttributeSpecifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitGccAttributeSpecifier(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitGccAttributeSpecifier(this);
else return visitor.visitChildren(this);
}
}
public final GccAttributeSpecifierContext gccAttributeSpecifier() throws RecognitionException {
GccAttributeSpecifierContext _localctx = new GccAttributeSpecifierContext(_ctx, getState());
enterRule(_localctx, 124, RULE_gccAttributeSpecifier);
try {
enterOuterAlt(_localctx, 1);
{
setState(689);
match(T__11);
setState(690);
match(LeftParen);
setState(691);
match(LeftParen);
setState(692);
gccAttributeList();
setState(693);
match(RightParen);
setState(694);
match(RightParen);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GccAttributeListContext extends ParserRuleContext {
public List gccAttribute() {
return getRuleContexts(GccAttributeContext.class);
}
public GccAttributeContext gccAttribute(int i) {
return getRuleContext(GccAttributeContext.class,i);
}
public List Comma() { return getTokens(CParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(CParser.Comma, i);
}
public GccAttributeListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gccAttributeList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterGccAttributeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitGccAttributeList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitGccAttributeList(this);
else return visitor.visitChildren(this);
}
}
public final GccAttributeListContext gccAttributeList() throws RecognitionException {
GccAttributeListContext _localctx = new GccAttributeListContext(_ctx, getState());
enterRule(_localctx, 126, RULE_gccAttributeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(697);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__10) | (1L << T__11) | (1L << T__12) | (1L << PRETTY_FUNC) | (1L << Extension) | (1L << Auto) | (1L << Break) | (1L << Case) | (1L << Char) | (1L << Const) | (1L << Continue) | (1L << Default) | (1L << Do) | (1L << Double) | (1L << Else) | (1L << Enum) | (1L << Extern) | (1L << Float) | (1L << For) | (1L << Goto) | (1L << If) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Register) | (1L << Restrict) | (1L << Return) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static) | (1L << Struct) | (1L << Switch) | (1L << Typedef) | (1L << Union) | (1L << Unsigned) | (1L << Void) | (1L << Volatile) | (1L << While) | (1L << Alignas) | (1L << Alignof) | (1L << Atomic) | (1L << Bool) | (1L << Complex) | (1L << Generic) | (1L << Imaginary) | (1L << Noreturn) | (1L << StaticAssert) | (1L << ThreadLocal) | (1L << LeftBracket) | (1L << RightBracket))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (LeftBrace - 64)) | (1L << (RightBrace - 64)) | (1L << (Less - 64)) | (1L << (LessEqual - 64)) | (1L << (Greater - 64)) | (1L << (GreaterEqual - 64)) | (1L << (LeftShift - 64)) | (1L << (RightShift - 64)) | (1L << (Plus - 64)) | (1L << (PlusPlus - 64)) | (1L << (Minus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Star - 64)) | (1L << (Div - 64)) | (1L << (Mod - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (AndAnd - 64)) | (1L << (OrOr - 64)) | (1L << (Caret - 64)) | (1L << (Not - 64)) | (1L << (Tilde - 64)) | (1L << (Question - 64)) | (1L << (Colon - 64)) | (1L << (Semi - 64)) | (1L << (Assign - 64)) | (1L << (StarAssign - 64)) | (1L << (DivAssign - 64)) | (1L << (ModAssign - 64)) | (1L << (PlusAssign - 64)) | (1L << (MinusAssign - 64)) | (1L << (LeftShiftAssign - 64)) | (1L << (RightShiftAssign - 64)) | (1L << (AndAssign - 64)) | (1L << (XorAssign - 64)) | (1L << (OrAssign - 64)) | (1L << (Equal - 64)) | (1L << (NotEqual - 64)) | (1L << (Arrow - 64)) | (1L << (Dot - 64)) | (1L << (Ellipsis - 64)) | (1L << (Identifier - 64)) | (1L << (Constant - 64)) | (1L << (DigitSequence - 64)) | (1L << (StringLiteral - 64)) | (1L << (ComplexDefine - 64)) | (1L << (IncludeDirective - 64)) | (1L << (AsmBlock - 64)) | (1L << (LineAfterPreprocessing - 64)) | (1L << (LineDirective - 64)) | (1L << (PragmaDirective - 64)) | (1L << (Whitespace - 64)) | (1L << (Newline - 64)) | (1L << (BlockComment - 64)) | (1L << (LineComment - 64)) | (1L << (WORD - 64)))) != 0)) {
{
setState(696);
gccAttribute();
}
}
setState(705);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Comma) {
{
{
setState(699);
match(Comma);
setState(701);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__10) | (1L << T__11) | (1L << T__12) | (1L << PRETTY_FUNC) | (1L << Extension) | (1L << Auto) | (1L << Break) | (1L << Case) | (1L << Char) | (1L << Const) | (1L << Continue) | (1L << Default) | (1L << Do) | (1L << Double) | (1L << Else) | (1L << Enum) | (1L << Extern) | (1L << Float) | (1L << For) | (1L << Goto) | (1L << If) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Register) | (1L << Restrict) | (1L << Return) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static) | (1L << Struct) | (1L << Switch) | (1L << Typedef) | (1L << Union) | (1L << Unsigned) | (1L << Void) | (1L << Volatile) | (1L << While) | (1L << Alignas) | (1L << Alignof) | (1L << Atomic) | (1L << Bool) | (1L << Complex) | (1L << Generic) | (1L << Imaginary) | (1L << Noreturn) | (1L << StaticAssert) | (1L << ThreadLocal) | (1L << LeftBracket) | (1L << RightBracket))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (LeftBrace - 64)) | (1L << (RightBrace - 64)) | (1L << (Less - 64)) | (1L << (LessEqual - 64)) | (1L << (Greater - 64)) | (1L << (GreaterEqual - 64)) | (1L << (LeftShift - 64)) | (1L << (RightShift - 64)) | (1L << (Plus - 64)) | (1L << (PlusPlus - 64)) | (1L << (Minus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Star - 64)) | (1L << (Div - 64)) | (1L << (Mod - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (AndAnd - 64)) | (1L << (OrOr - 64)) | (1L << (Caret - 64)) | (1L << (Not - 64)) | (1L << (Tilde - 64)) | (1L << (Question - 64)) | (1L << (Colon - 64)) | (1L << (Semi - 64)) | (1L << (Assign - 64)) | (1L << (StarAssign - 64)) | (1L << (DivAssign - 64)) | (1L << (ModAssign - 64)) | (1L << (PlusAssign - 64)) | (1L << (MinusAssign - 64)) | (1L << (LeftShiftAssign - 64)) | (1L << (RightShiftAssign - 64)) | (1L << (AndAssign - 64)) | (1L << (XorAssign - 64)) | (1L << (OrAssign - 64)) | (1L << (Equal - 64)) | (1L << (NotEqual - 64)) | (1L << (Arrow - 64)) | (1L << (Dot - 64)) | (1L << (Ellipsis - 64)) | (1L << (Identifier - 64)) | (1L << (Constant - 64)) | (1L << (DigitSequence - 64)) | (1L << (StringLiteral - 64)) | (1L << (ComplexDefine - 64)) | (1L << (IncludeDirective - 64)) | (1L << (AsmBlock - 64)) | (1L << (LineAfterPreprocessing - 64)) | (1L << (LineDirective - 64)) | (1L << (PragmaDirective - 64)) | (1L << (Whitespace - 64)) | (1L << (Newline - 64)) | (1L << (BlockComment - 64)) | (1L << (LineComment - 64)) | (1L << (WORD - 64)))) != 0)) {
{
setState(700);
gccAttribute();
}
}
}
}
setState(707);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class GccAttributeContext extends ParserRuleContext {
public TerminalNode Comma() { return getToken(CParser.Comma, 0); }
public List LeftParen() { return getTokens(CParser.LeftParen); }
public TerminalNode LeftParen(int i) {
return getToken(CParser.LeftParen, i);
}
public List RightParen() { return getTokens(CParser.RightParen); }
public TerminalNode RightParen(int i) {
return getToken(CParser.RightParen, i);
}
public ArgumentExpressionListContext argumentExpressionList() {
return getRuleContext(ArgumentExpressionListContext.class,0);
}
public GccAttributeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_gccAttribute; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterGccAttribute(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitGccAttribute(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitGccAttribute(this);
else return visitor.visitChildren(this);
}
}
public final GccAttributeContext gccAttribute() throws RecognitionException {
GccAttributeContext _localctx = new GccAttributeContext(_ctx, getState());
enterRule(_localctx, 128, RULE_gccAttribute);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(708);
_la = _input.LA(1);
if ( _la <= 0 || (((((_la - 60)) & ~0x3f) == 0 && ((1L << (_la - 60)) & ((1L << (LeftParen - 60)) | (1L << (RightParen - 60)) | (1L << (Comma - 60)))) != 0)) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
setState(714);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LeftParen) {
{
setState(709);
match(LeftParen);
setState(711);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRETTY_FUNC) | (1L << Extension) | (1L << Sizeof) | (1L << Alignof) | (1L << LeftParen))) != 0) || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (Plus - 72)) | (1L << (PlusPlus - 72)) | (1L << (Minus - 72)) | (1L << (MinusMinus - 72)) | (1L << (Star - 72)) | (1L << (And - 72)) | (1L << (Not - 72)) | (1L << (Tilde - 72)) | (1L << (Identifier - 72)) | (1L << (Constant - 72)) | (1L << (StringLiteral - 72)))) != 0)) {
{
setState(710);
argumentExpressionList();
}
}
setState(713);
match(RightParen);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class NestedParenthesesBlockContext extends ParserRuleContext {
public List LeftParen() { return getTokens(CParser.LeftParen); }
public TerminalNode LeftParen(int i) {
return getToken(CParser.LeftParen, i);
}
public List nestedParenthesesBlock() {
return getRuleContexts(NestedParenthesesBlockContext.class);
}
public NestedParenthesesBlockContext nestedParenthesesBlock(int i) {
return getRuleContext(NestedParenthesesBlockContext.class,i);
}
public List RightParen() { return getTokens(CParser.RightParen); }
public TerminalNode RightParen(int i) {
return getToken(CParser.RightParen, i);
}
public NestedParenthesesBlockContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_nestedParenthesesBlock; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterNestedParenthesesBlock(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitNestedParenthesesBlock(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitNestedParenthesesBlock(this);
else return visitor.visitChildren(this);
}
}
public final NestedParenthesesBlockContext nestedParenthesesBlock() throws RecognitionException {
NestedParenthesesBlockContext _localctx = new NestedParenthesesBlockContext(_ctx, getState());
enterRule(_localctx, 130, RULE_nestedParenthesesBlock);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(723);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__10) | (1L << T__11) | (1L << T__12) | (1L << PRETTY_FUNC) | (1L << Extension) | (1L << Auto) | (1L << Break) | (1L << Case) | (1L << Char) | (1L << Const) | (1L << Continue) | (1L << Default) | (1L << Do) | (1L << Double) | (1L << Else) | (1L << Enum) | (1L << Extern) | (1L << Float) | (1L << For) | (1L << Goto) | (1L << If) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Register) | (1L << Restrict) | (1L << Return) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static) | (1L << Struct) | (1L << Switch) | (1L << Typedef) | (1L << Union) | (1L << Unsigned) | (1L << Void) | (1L << Volatile) | (1L << While) | (1L << Alignas) | (1L << Alignof) | (1L << Atomic) | (1L << Bool) | (1L << Complex) | (1L << Generic) | (1L << Imaginary) | (1L << Noreturn) | (1L << StaticAssert) | (1L << ThreadLocal) | (1L << LeftParen) | (1L << LeftBracket) | (1L << RightBracket))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (LeftBrace - 64)) | (1L << (RightBrace - 64)) | (1L << (Less - 64)) | (1L << (LessEqual - 64)) | (1L << (Greater - 64)) | (1L << (GreaterEqual - 64)) | (1L << (LeftShift - 64)) | (1L << (RightShift - 64)) | (1L << (Plus - 64)) | (1L << (PlusPlus - 64)) | (1L << (Minus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Star - 64)) | (1L << (Div - 64)) | (1L << (Mod - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (AndAnd - 64)) | (1L << (OrOr - 64)) | (1L << (Caret - 64)) | (1L << (Not - 64)) | (1L << (Tilde - 64)) | (1L << (Question - 64)) | (1L << (Colon - 64)) | (1L << (Semi - 64)) | (1L << (Comma - 64)) | (1L << (Assign - 64)) | (1L << (StarAssign - 64)) | (1L << (DivAssign - 64)) | (1L << (ModAssign - 64)) | (1L << (PlusAssign - 64)) | (1L << (MinusAssign - 64)) | (1L << (LeftShiftAssign - 64)) | (1L << (RightShiftAssign - 64)) | (1L << (AndAssign - 64)) | (1L << (XorAssign - 64)) | (1L << (OrAssign - 64)) | (1L << (Equal - 64)) | (1L << (NotEqual - 64)) | (1L << (Arrow - 64)) | (1L << (Dot - 64)) | (1L << (Ellipsis - 64)) | (1L << (Identifier - 64)) | (1L << (Constant - 64)) | (1L << (DigitSequence - 64)) | (1L << (StringLiteral - 64)) | (1L << (ComplexDefine - 64)) | (1L << (IncludeDirective - 64)) | (1L << (AsmBlock - 64)) | (1L << (LineAfterPreprocessing - 64)) | (1L << (LineDirective - 64)) | (1L << (PragmaDirective - 64)) | (1L << (Whitespace - 64)) | (1L << (Newline - 64)) | (1L << (BlockComment - 64)) | (1L << (LineComment - 64)) | (1L << (WORD - 64)))) != 0)) {
{
setState(721);
_errHandler.sync(this);
switch (_input.LA(1)) {
case T__0:
case T__1:
case T__2:
case T__3:
case T__4:
case T__5:
case T__6:
case T__7:
case T__8:
case T__9:
case T__10:
case T__11:
case T__12:
case PRETTY_FUNC:
case Extension:
case Auto:
case Break:
case Case:
case Char:
case Const:
case Continue:
case Default:
case Do:
case Double:
case Else:
case Enum:
case Extern:
case Float:
case For:
case Goto:
case If:
case Inline:
case Int:
case Long:
case Register:
case Restrict:
case Return:
case Short:
case Signed:
case Sizeof:
case Static:
case Struct:
case Switch:
case Typedef:
case Union:
case Unsigned:
case Void:
case Volatile:
case While:
case Alignas:
case Alignof:
case Atomic:
case Bool:
case Complex:
case Generic:
case Imaginary:
case Noreturn:
case StaticAssert:
case ThreadLocal:
case LeftBracket:
case RightBracket:
case LeftBrace:
case RightBrace:
case Less:
case LessEqual:
case Greater:
case GreaterEqual:
case LeftShift:
case RightShift:
case Plus:
case PlusPlus:
case Minus:
case MinusMinus:
case Star:
case Div:
case Mod:
case And:
case Or:
case AndAnd:
case OrOr:
case Caret:
case Not:
case Tilde:
case Question:
case Colon:
case Semi:
case Comma:
case Assign:
case StarAssign:
case DivAssign:
case ModAssign:
case PlusAssign:
case MinusAssign:
case LeftShiftAssign:
case RightShiftAssign:
case AndAssign:
case XorAssign:
case OrAssign:
case Equal:
case NotEqual:
case Arrow:
case Dot:
case Ellipsis:
case Identifier:
case Constant:
case DigitSequence:
case StringLiteral:
case ComplexDefine:
case IncludeDirective:
case AsmBlock:
case LineAfterPreprocessing:
case LineDirective:
case PragmaDirective:
case Whitespace:
case Newline:
case BlockComment:
case LineComment:
case WORD:
{
setState(716);
_la = _input.LA(1);
if ( _la <= 0 || (_la==LeftParen || _la==RightParen) ) {
_errHandler.recoverInline(this);
}
else {
if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
_errHandler.reportMatch(this);
consume();
}
}
break;
case LeftParen:
{
setState(717);
match(LeftParen);
setState(718);
nestedParenthesesBlock();
setState(719);
match(RightParen);
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(725);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PointerContext extends ParserRuleContext {
public Token s76;
public List stars = new ArrayList();
public List Caret() { return getTokens(CParser.Caret); }
public TerminalNode Caret(int i) {
return getToken(CParser.Caret, i);
}
public List Star() { return getTokens(CParser.Star); }
public TerminalNode Star(int i) {
return getToken(CParser.Star, i);
}
public List typeQualifierList() {
return getRuleContexts(TypeQualifierListContext.class);
}
public TypeQualifierListContext typeQualifierList(int i) {
return getRuleContext(TypeQualifierListContext.class,i);
}
public PointerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_pointer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterPointer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitPointer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitPointer(this);
else return visitor.visitChildren(this);
}
}
public final PointerContext pointer() throws RecognitionException {
PointerContext _localctx = new PointerContext(_ctx, getState());
enterRule(_localctx, 132, RULE_pointer);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(736);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(728);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Star:
{
setState(726);
((PointerContext)_localctx).s76 = match(Star);
((PointerContext)_localctx).stars.add(((PointerContext)_localctx).s76);
}
break;
case Caret:
{
setState(727);
match(Caret);
}
break;
default:
throw new NoViableAltException(this);
}
setState(731);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==T__12) {
{
setState(730);
match(T__12);
}
}
setState(734);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
case 1:
{
setState(733);
typeQualifierList();
}
break;
}
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(738);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,78,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TypeQualifierListContext extends ParserRuleContext {
public List typeQualifier() {
return getRuleContexts(TypeQualifierContext.class);
}
public TypeQualifierContext typeQualifier(int i) {
return getRuleContext(TypeQualifierContext.class,i);
}
public TypeQualifierListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_typeQualifierList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterTypeQualifierList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypeQualifierList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypeQualifierList(this);
else return visitor.visitChildren(this);
}
}
public final TypeQualifierListContext typeQualifierList() throws RecognitionException {
TypeQualifierListContext _localctx = new TypeQualifierListContext(_ctx, getState());
enterRule(_localctx, 134, RULE_typeQualifierList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(741);
_errHandler.sync(this);
_alt = 1;
do {
switch (_alt) {
case 1:
{
{
setState(740);
typeQualifier();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(743);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,79,_ctx);
} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParameterTypeListContext extends ParserRuleContext {
public Token ellipses;
public ParameterListContext parameterList() {
return getRuleContext(ParameterListContext.class,0);
}
public TerminalNode Comma() { return getToken(CParser.Comma, 0); }
public TerminalNode Ellipsis() { return getToken(CParser.Ellipsis, 0); }
public ParameterTypeListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterTypeList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterParameterTypeList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitParameterTypeList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitParameterTypeList(this);
else return visitor.visitChildren(this);
}
}
public final ParameterTypeListContext parameterTypeList() throws RecognitionException {
ParameterTypeListContext _localctx = new ParameterTypeListContext(_ctx, getState());
enterRule(_localctx, 136, RULE_parameterTypeList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(745);
parameterList();
setState(748);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Comma) {
{
setState(746);
match(Comma);
setState(747);
((ParameterTypeListContext)_localctx).ellipses = match(Ellipsis);
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParameterListContext extends ParserRuleContext {
public List parameterDeclaration() {
return getRuleContexts(ParameterDeclarationContext.class);
}
public ParameterDeclarationContext parameterDeclaration(int i) {
return getRuleContext(ParameterDeclarationContext.class,i);
}
public List Comma() { return getTokens(CParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(CParser.Comma, i);
}
public ParameterListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterParameterList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitParameterList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitParameterList(this);
else return visitor.visitChildren(this);
}
}
public final ParameterListContext parameterList() throws RecognitionException {
ParameterListContext _localctx = new ParameterListContext(_ctx, getState());
enterRule(_localctx, 138, RULE_parameterList);
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(750);
parameterDeclaration();
setState(755);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,81,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(751);
match(Comma);
setState(752);
parameterDeclaration();
}
}
}
setState(757);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,81,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ParameterDeclarationContext extends ParserRuleContext {
public ParameterDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameterDeclaration; }
public ParameterDeclarationContext() { }
public void copyFrom(ParameterDeclarationContext ctx) {
super.copyFrom(ctx);
}
}
public static class AbstractParameterDeclarationContext extends ParameterDeclarationContext {
public DeclarationSpecifiers2Context declarationSpecifiers2() {
return getRuleContext(DeclarationSpecifiers2Context.class,0);
}
public AbstractDeclaratorContext abstractDeclarator() {
return getRuleContext(AbstractDeclaratorContext.class,0);
}
public AbstractParameterDeclarationContext(ParameterDeclarationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterAbstractParameterDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitAbstractParameterDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitAbstractParameterDeclaration(this);
else return visitor.visitChildren(this);
}
}
public static class OrdinaryParameterDeclarationContext extends ParameterDeclarationContext {
public DeclarationSpecifiersContext declarationSpecifiers() {
return getRuleContext(DeclarationSpecifiersContext.class,0);
}
public DeclaratorContext declarator() {
return getRuleContext(DeclaratorContext.class,0);
}
public OrdinaryParameterDeclarationContext(ParameterDeclarationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterOrdinaryParameterDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitOrdinaryParameterDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitOrdinaryParameterDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ParameterDeclarationContext parameterDeclaration() throws RecognitionException {
ParameterDeclarationContext _localctx = new ParameterDeclarationContext(_ctx, getState());
enterRule(_localctx, 140, RULE_parameterDeclaration);
int _la;
try {
setState(765);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,83,_ctx) ) {
case 1:
_localctx = new OrdinaryParameterDeclarationContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(758);
declarationSpecifiers();
setState(759);
declarator();
}
break;
case 2:
_localctx = new AbstractParameterDeclarationContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(761);
declarationSpecifiers2();
setState(763);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 60)) & ~0x3f) == 0 && ((1L << (_la - 60)) & ((1L << (LeftParen - 60)) | (1L << (LeftBracket - 60)) | (1L << (Star - 60)) | (1L << (Caret - 60)))) != 0)) {
{
setState(762);
abstractDeclarator();
}
}
}
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 SpecifierQualifierListContext specifierQualifierList() {
return getRuleContext(SpecifierQualifierListContext.class,0);
}
public AbstractDeclaratorContext abstractDeclarator() {
return getRuleContext(AbstractDeclaratorContext.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 CListener ) ((CListener)listener).enterTypeName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypeName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypeName(this);
else return visitor.visitChildren(this);
}
}
public final TypeNameContext typeName() throws RecognitionException {
TypeNameContext _localctx = new TypeNameContext(_ctx, getState());
enterRule(_localctx, 142, RULE_typeName);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(767);
specifierQualifierList();
setState(769);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 60)) & ~0x3f) == 0 && ((1L << (_la - 60)) & ((1L << (LeftParen - 60)) | (1L << (LeftBracket - 60)) | (1L << (Star - 60)) | (1L << (Caret - 60)))) != 0)) {
{
setState(768);
abstractDeclarator();
}
}
}
}
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 PointerContext pointer() {
return getRuleContext(PointerContext.class,0);
}
public DirectAbstractDeclaratorContext directAbstractDeclarator() {
return getRuleContext(DirectAbstractDeclaratorContext.class,0);
}
public List gccDeclaratorExtension() {
return getRuleContexts(GccDeclaratorExtensionContext.class);
}
public GccDeclaratorExtensionContext gccDeclaratorExtension(int i) {
return getRuleContext(GccDeclaratorExtensionContext.class,i);
}
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 CListener ) ((CListener)listener).enterAbstractDeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitAbstractDeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitAbstractDeclarator(this);
else return visitor.visitChildren(this);
}
}
public final AbstractDeclaratorContext abstractDeclarator() throws RecognitionException {
AbstractDeclaratorContext _localctx = new AbstractDeclaratorContext(_ctx, getState());
enterRule(_localctx, 144, RULE_abstractDeclarator);
int _la;
try {
setState(782);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(771);
pointer();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(773);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Star || _la==Caret) {
{
setState(772);
pointer();
}
}
setState(775);
directAbstractDeclarator(0);
setState(779);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__9) | (1L << T__10) | (1L << T__11))) != 0)) {
{
{
setState(776);
gccDeclaratorExtension();
}
}
setState(781);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DirectAbstractDeclaratorContext extends ParserRuleContext {
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public AbstractDeclaratorContext abstractDeclarator() {
return getRuleContext(AbstractDeclaratorContext.class,0);
}
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public List gccDeclaratorExtension() {
return getRuleContexts(GccDeclaratorExtensionContext.class);
}
public GccDeclaratorExtensionContext gccDeclaratorExtension(int i) {
return getRuleContext(GccDeclaratorExtensionContext.class,i);
}
public TerminalNode LeftBracket() { return getToken(CParser.LeftBracket, 0); }
public TerminalNode RightBracket() { return getToken(CParser.RightBracket, 0); }
public TypeQualifierListContext typeQualifierList() {
return getRuleContext(TypeQualifierListContext.class,0);
}
public AssignmentExpressionContext assignmentExpression() {
return getRuleContext(AssignmentExpressionContext.class,0);
}
public TerminalNode Static() { return getToken(CParser.Static, 0); }
public TerminalNode Star() { return getToken(CParser.Star, 0); }
public ParameterTypeListContext parameterTypeList() {
return getRuleContext(ParameterTypeListContext.class,0);
}
public DirectAbstractDeclaratorContext directAbstractDeclarator() {
return getRuleContext(DirectAbstractDeclaratorContext.class,0);
}
public DirectAbstractDeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_directAbstractDeclarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDirectAbstractDeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDirectAbstractDeclarator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDirectAbstractDeclarator(this);
else return visitor.visitChildren(this);
}
}
public final DirectAbstractDeclaratorContext directAbstractDeclarator() throws RecognitionException {
return directAbstractDeclarator(0);
}
private DirectAbstractDeclaratorContext directAbstractDeclarator(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
DirectAbstractDeclaratorContext _localctx = new DirectAbstractDeclaratorContext(_ctx, _parentState);
DirectAbstractDeclaratorContext _prevctx = _localctx;
int _startState = 146;
enterRecursionRule(_localctx, 146, RULE_directAbstractDeclarator, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(830);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
case 1:
{
setState(785);
match(LeftParen);
setState(786);
abstractDeclarator();
setState(787);
match(RightParen);
setState(791);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,88,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(788);
gccDeclaratorExtension();
}
}
}
setState(793);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,88,_ctx);
}
}
break;
case 2:
{
setState(794);
match(LeftBracket);
setState(796);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Const) | (1L << Restrict) | (1L << Volatile) | (1L << Atomic))) != 0)) {
{
setState(795);
typeQualifierList();
}
}
setState(799);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRETTY_FUNC) | (1L << Extension) | (1L << Sizeof) | (1L << Alignof) | (1L << LeftParen))) != 0) || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (Plus - 72)) | (1L << (PlusPlus - 72)) | (1L << (Minus - 72)) | (1L << (MinusMinus - 72)) | (1L << (Star - 72)) | (1L << (And - 72)) | (1L << (Not - 72)) | (1L << (Tilde - 72)) | (1L << (Identifier - 72)) | (1L << (Constant - 72)) | (1L << (StringLiteral - 72)))) != 0)) {
{
setState(798);
assignmentExpression();
}
}
setState(801);
match(RightBracket);
}
break;
case 3:
{
setState(802);
match(LeftBracket);
setState(803);
match(Static);
setState(805);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Const) | (1L << Restrict) | (1L << Volatile) | (1L << Atomic))) != 0)) {
{
setState(804);
typeQualifierList();
}
}
setState(807);
assignmentExpression();
setState(808);
match(RightBracket);
}
break;
case 4:
{
setState(810);
match(LeftBracket);
setState(811);
typeQualifierList();
setState(812);
match(Static);
setState(813);
assignmentExpression();
setState(814);
match(RightBracket);
}
break;
case 5:
{
setState(816);
match(LeftBracket);
setState(817);
match(Star);
setState(818);
match(RightBracket);
}
break;
case 6:
{
setState(819);
match(LeftParen);
setState(821);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__11) | (1L << Extension) | (1L << Auto) | (1L << Char) | (1L << Const) | (1L << Double) | (1L << Enum) | (1L << Extern) | (1L << Float) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Register) | (1L << Restrict) | (1L << Short) | (1L << Signed) | (1L << Static) | (1L << Struct) | (1L << Typedef) | (1L << Union) | (1L << Unsigned) | (1L << Void) | (1L << Volatile) | (1L << Alignas) | (1L << Atomic) | (1L << Bool) | (1L << Complex) | (1L << Noreturn) | (1L << ThreadLocal))) != 0) || _la==Identifier) {
{
setState(820);
parameterTypeList();
}
}
setState(823);
match(RightParen);
setState(827);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,93,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(824);
gccDeclaratorExtension();
}
}
}
setState(829);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,93,_ctx);
}
}
break;
}
_ctx.stop = _input.LT(-1);
setState(875);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,101,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(873);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) {
case 1:
{
_localctx = new DirectAbstractDeclaratorContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_directAbstractDeclarator);
setState(832);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(833);
match(LeftBracket);
setState(835);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Const) | (1L << Restrict) | (1L << Volatile) | (1L << Atomic))) != 0)) {
{
setState(834);
typeQualifierList();
}
}
setState(838);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRETTY_FUNC) | (1L << Extension) | (1L << Sizeof) | (1L << Alignof) | (1L << LeftParen))) != 0) || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (Plus - 72)) | (1L << (PlusPlus - 72)) | (1L << (Minus - 72)) | (1L << (MinusMinus - 72)) | (1L << (Star - 72)) | (1L << (And - 72)) | (1L << (Not - 72)) | (1L << (Tilde - 72)) | (1L << (Identifier - 72)) | (1L << (Constant - 72)) | (1L << (StringLiteral - 72)))) != 0)) {
{
setState(837);
assignmentExpression();
}
}
setState(840);
match(RightBracket);
}
break;
case 2:
{
_localctx = new DirectAbstractDeclaratorContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_directAbstractDeclarator);
setState(841);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(842);
match(LeftBracket);
setState(843);
match(Static);
setState(845);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Const) | (1L << Restrict) | (1L << Volatile) | (1L << Atomic))) != 0)) {
{
setState(844);
typeQualifierList();
}
}
setState(847);
assignmentExpression();
setState(848);
match(RightBracket);
}
break;
case 3:
{
_localctx = new DirectAbstractDeclaratorContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_directAbstractDeclarator);
setState(850);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(851);
match(LeftBracket);
setState(852);
typeQualifierList();
setState(853);
match(Static);
setState(854);
assignmentExpression();
setState(855);
match(RightBracket);
}
break;
case 4:
{
_localctx = new DirectAbstractDeclaratorContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_directAbstractDeclarator);
setState(857);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(858);
match(LeftBracket);
setState(859);
match(Star);
setState(860);
match(RightBracket);
}
break;
case 5:
{
_localctx = new DirectAbstractDeclaratorContext(_parentctx, _parentState);
pushNewRecursionContext(_localctx, _startState, RULE_directAbstractDeclarator);
setState(861);
if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)");
setState(862);
match(LeftParen);
setState(864);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__11) | (1L << Extension) | (1L << Auto) | (1L << Char) | (1L << Const) | (1L << Double) | (1L << Enum) | (1L << Extern) | (1L << Float) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Register) | (1L << Restrict) | (1L << Short) | (1L << Signed) | (1L << Static) | (1L << Struct) | (1L << Typedef) | (1L << Union) | (1L << Unsigned) | (1L << Void) | (1L << Volatile) | (1L << Alignas) | (1L << Atomic) | (1L << Bool) | (1L << Complex) | (1L << Noreturn) | (1L << ThreadLocal))) != 0) || _la==Identifier) {
{
setState(863);
parameterTypeList();
}
}
setState(866);
match(RightParen);
setState(870);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,99,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(867);
gccDeclaratorExtension();
}
}
}
setState(872);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,99,_ctx);
}
}
break;
}
}
}
setState(877);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,101,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class TypedefNameContext extends ParserRuleContext {
public TerminalNode Identifier() { return getToken(CParser.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 CListener ) ((CListener)listener).enterTypedefName(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTypedefName(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTypedefName(this);
else return visitor.visitChildren(this);
}
}
public final TypedefNameContext typedefName() throws RecognitionException {
TypedefNameContext _localctx = new TypedefNameContext(_ctx, getState());
enterRule(_localctx, 148, RULE_typedefName);
try {
enterOuterAlt(_localctx, 1);
{
setState(878);
match(Identifier);
}
}
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 AssignmentExpressionContext assignmentExpression() {
return getRuleContext(AssignmentExpressionContext.class,0);
}
public TerminalNode LeftBrace() { return getToken(CParser.LeftBrace, 0); }
public InitializerListContext initializerList() {
return getRuleContext(InitializerListContext.class,0);
}
public TerminalNode RightBrace() { return getToken(CParser.RightBrace, 0); }
public TerminalNode Comma() { return getToken(CParser.Comma, 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 CListener ) ((CListener)listener).enterInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitInitializer(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitInitializer(this);
else return visitor.visitChildren(this);
}
}
public final InitializerContext initializer() throws RecognitionException {
InitializerContext _localctx = new InitializerContext(_ctx, getState());
enterRule(_localctx, 150, RULE_initializer);
int _la;
try {
setState(888);
_errHandler.sync(this);
switch (_input.LA(1)) {
case PRETTY_FUNC:
case Extension:
case Sizeof:
case Alignof:
case LeftParen:
case Plus:
case PlusPlus:
case Minus:
case MinusMinus:
case Star:
case And:
case Not:
case Tilde:
case Identifier:
case Constant:
case StringLiteral:
enterOuterAlt(_localctx, 1);
{
setState(880);
assignmentExpression();
}
break;
case LeftBrace:
enterOuterAlt(_localctx, 2);
{
setState(881);
match(LeftBrace);
setState(882);
initializerList();
setState(884);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==Comma) {
{
setState(883);
match(Comma);
}
}
setState(886);
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 InitializerListContext extends ParserRuleContext {
public InitializerContext initializer;
public List initializers = new ArrayList();
public List initializer() {
return getRuleContexts(InitializerContext.class);
}
public InitializerContext initializer(int i) {
return getRuleContext(InitializerContext.class,i);
}
public List designation() {
return getRuleContexts(DesignationContext.class);
}
public DesignationContext designation(int i) {
return getRuleContext(DesignationContext.class,i);
}
public List Comma() { return getTokens(CParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(CParser.Comma, i);
}
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 CListener ) ((CListener)listener).enterInitializerList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitInitializerList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitInitializerList(this);
else return visitor.visitChildren(this);
}
}
public final InitializerListContext initializerList() throws RecognitionException {
InitializerListContext _localctx = new InitializerListContext(_ctx, getState());
enterRule(_localctx, 152, RULE_initializerList);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(891);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LeftBracket || _la==Dot) {
{
setState(890);
designation();
}
}
setState(893);
((InitializerListContext)_localctx).initializer = initializer();
((InitializerListContext)_localctx).initializers.add(((InitializerListContext)_localctx).initializer);
setState(901);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,106,_ctx);
while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
if ( _alt==1 ) {
{
{
setState(894);
match(Comma);
setState(896);
_errHandler.sync(this);
_la = _input.LA(1);
if (_la==LeftBracket || _la==Dot) {
{
setState(895);
designation();
}
}
setState(898);
((InitializerListContext)_localctx).initializer = initializer();
((InitializerListContext)_localctx).initializers.add(((InitializerListContext)_localctx).initializer);
}
}
}
setState(903);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,106,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DesignationContext extends ParserRuleContext {
public DesignatorListContext designatorList() {
return getRuleContext(DesignatorListContext.class,0);
}
public TerminalNode Assign() { return getToken(CParser.Assign, 0); }
public DesignationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_designation; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDesignation(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDesignation(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDesignation(this);
else return visitor.visitChildren(this);
}
}
public final DesignationContext designation() throws RecognitionException {
DesignationContext _localctx = new DesignationContext(_ctx, getState());
enterRule(_localctx, 154, RULE_designation);
try {
enterOuterAlt(_localctx, 1);
{
setState(904);
designatorList();
setState(905);
match(Assign);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DesignatorListContext extends ParserRuleContext {
public List designator() {
return getRuleContexts(DesignatorContext.class);
}
public DesignatorContext designator(int i) {
return getRuleContext(DesignatorContext.class,i);
}
public DesignatorListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_designatorList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDesignatorList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDesignatorList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDesignatorList(this);
else return visitor.visitChildren(this);
}
}
public final DesignatorListContext designatorList() throws RecognitionException {
DesignatorListContext _localctx = new DesignatorListContext(_ctx, getState());
enterRule(_localctx, 156, RULE_designatorList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(908);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(907);
designator();
}
}
setState(910);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==LeftBracket || _la==Dot );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class DesignatorContext extends ParserRuleContext {
public TerminalNode LeftBracket() { return getToken(CParser.LeftBracket, 0); }
public ConstantExpressionContext constantExpression() {
return getRuleContext(ConstantExpressionContext.class,0);
}
public TerminalNode RightBracket() { return getToken(CParser.RightBracket, 0); }
public TerminalNode Dot() { return getToken(CParser.Dot, 0); }
public TerminalNode Identifier() { return getToken(CParser.Identifier, 0); }
public DesignatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_designator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDesignator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDesignator(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDesignator(this);
else return visitor.visitChildren(this);
}
}
public final DesignatorContext designator() throws RecognitionException {
DesignatorContext _localctx = new DesignatorContext(_ctx, getState());
enterRule(_localctx, 158, RULE_designator);
try {
setState(918);
_errHandler.sync(this);
switch (_input.LA(1)) {
case LeftBracket:
enterOuterAlt(_localctx, 1);
{
setState(912);
match(LeftBracket);
setState(913);
constantExpression();
setState(914);
match(RightBracket);
}
break;
case Dot:
enterOuterAlt(_localctx, 2);
{
setState(916);
match(Dot);
setState(917);
match(Identifier);
}
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 StatementContext extends ParserRuleContext {
public LabeledStatementContext labeledStatement() {
return getRuleContext(LabeledStatementContext.class,0);
}
public CompoundStatementContext compoundStatement() {
return getRuleContext(CompoundStatementContext.class,0);
}
public ExpressionStatementContext expressionStatement() {
return getRuleContext(ExpressionStatementContext.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 TerminalNode Semi() { return getToken(CParser.Semi, 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 CListener ) ((CListener)listener).enterStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitStatement(this);
else return visitor.visitChildren(this);
}
}
public final StatementContext statement() throws RecognitionException {
StatementContext _localctx = new StatementContext(_ctx, getState());
enterRule(_localctx, 160, RULE_statement);
try {
setState(928);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(920);
labeledStatement();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(921);
compoundStatement();
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(922);
expressionStatement();
}
break;
case 4:
enterOuterAlt(_localctx, 4);
{
setState(923);
selectionStatement();
}
break;
case 5:
enterOuterAlt(_localctx, 5);
{
setState(924);
iterationStatement();
}
break;
case 6:
enterOuterAlt(_localctx, 6);
{
setState(925);
jumpStatement();
setState(926);
match(Semi);
}
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 LabeledStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_labeledStatement; }
public LabeledStatementContext() { }
public void copyFrom(LabeledStatementContext ctx) {
super.copyFrom(ctx);
}
}
public static class CaseStatementContext extends LabeledStatementContext {
public TerminalNode Case() { return getToken(CParser.Case, 0); }
public ConstantExpressionContext constantExpression() {
return getRuleContext(ConstantExpressionContext.class,0);
}
public TerminalNode Colon() { return getToken(CParser.Colon, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public CaseStatementContext(LabeledStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterCaseStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitCaseStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitCaseStatement(this);
else return visitor.visitChildren(this);
}
}
public static class DefaultStatementContext extends LabeledStatementContext {
public TerminalNode Default() { return getToken(CParser.Default, 0); }
public TerminalNode Colon() { return getToken(CParser.Colon, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public DefaultStatementContext(LabeledStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDefaultStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDefaultStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDefaultStatement(this);
else return visitor.visitChildren(this);
}
}
public static class IdentifierStatementContext extends LabeledStatementContext {
public TerminalNode Identifier() { return getToken(CParser.Identifier, 0); }
public TerminalNode Colon() { return getToken(CParser.Colon, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public IdentifierStatementContext(LabeledStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterIdentifierStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitIdentifierStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitIdentifierStatement(this);
else return visitor.visitChildren(this);
}
}
public final LabeledStatementContext labeledStatement() throws RecognitionException {
LabeledStatementContext _localctx = new LabeledStatementContext(_ctx, getState());
enterRule(_localctx, 162, RULE_labeledStatement);
try {
setState(941);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Identifier:
_localctx = new IdentifierStatementContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(930);
match(Identifier);
setState(931);
match(Colon);
setState(932);
statement();
}
break;
case Case:
_localctx = new CaseStatementContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(933);
match(Case);
setState(934);
constantExpression();
setState(935);
match(Colon);
setState(936);
statement();
}
break;
case Default:
_localctx = new DefaultStatementContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(938);
match(Default);
setState(939);
match(Colon);
setState(940);
statement();
}
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 CompoundStatementContext extends ParserRuleContext {
public TerminalNode LeftBrace() { return getToken(CParser.LeftBrace, 0); }
public TerminalNode RightBrace() { return getToken(CParser.RightBrace, 0); }
public BlockItemListContext blockItemList() {
return getRuleContext(BlockItemListContext.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 CListener ) ((CListener)listener).enterCompoundStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitCompoundStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitCompoundStatement(this);
else return visitor.visitChildren(this);
}
}
public final CompoundStatementContext compoundStatement() throws RecognitionException {
CompoundStatementContext _localctx = new CompoundStatementContext(_ctx, getState());
enterRule(_localctx, 164, RULE_compoundStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(943);
match(LeftBrace);
setState(945);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__11) | (1L << PRETTY_FUNC) | (1L << Extension) | (1L << Auto) | (1L << Break) | (1L << Case) | (1L << Char) | (1L << Const) | (1L << Continue) | (1L << Default) | (1L << Do) | (1L << Double) | (1L << Enum) | (1L << Extern) | (1L << Float) | (1L << For) | (1L << Goto) | (1L << If) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Register) | (1L << Restrict) | (1L << Return) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static) | (1L << Struct) | (1L << Switch) | (1L << Typedef) | (1L << Union) | (1L << Unsigned) | (1L << Void) | (1L << Volatile) | (1L << While) | (1L << Alignas) | (1L << Alignof) | (1L << Atomic) | (1L << Bool) | (1L << Complex) | (1L << Noreturn) | (1L << ThreadLocal) | (1L << LeftParen))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (LeftBrace - 64)) | (1L << (Plus - 64)) | (1L << (PlusPlus - 64)) | (1L << (Minus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Star - 64)) | (1L << (And - 64)) | (1L << (Not - 64)) | (1L << (Tilde - 64)) | (1L << (Semi - 64)) | (1L << (Identifier - 64)) | (1L << (Constant - 64)) | (1L << (StringLiteral - 64)))) != 0)) {
{
setState(944);
blockItemList();
}
}
setState(947);
match(RightBrace);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BlockItemListContext extends ParserRuleContext {
public List blockItem() {
return getRuleContexts(BlockItemContext.class);
}
public BlockItemContext blockItem(int i) {
return getRuleContext(BlockItemContext.class,i);
}
public BlockItemListContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_blockItemList; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterBlockItemList(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitBlockItemList(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitBlockItemList(this);
else return visitor.visitChildren(this);
}
}
public final BlockItemListContext blockItemList() throws RecognitionException {
BlockItemListContext _localctx = new BlockItemListContext(_ctx, getState());
enterRule(_localctx, 166, RULE_blockItemList);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(950);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(949);
blockItem();
}
}
setState(952);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__11) | (1L << PRETTY_FUNC) | (1L << Extension) | (1L << Auto) | (1L << Break) | (1L << Case) | (1L << Char) | (1L << Const) | (1L << Continue) | (1L << Default) | (1L << Do) | (1L << Double) | (1L << Enum) | (1L << Extern) | (1L << Float) | (1L << For) | (1L << Goto) | (1L << If) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Register) | (1L << Restrict) | (1L << Return) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static) | (1L << Struct) | (1L << Switch) | (1L << Typedef) | (1L << Union) | (1L << Unsigned) | (1L << Void) | (1L << Volatile) | (1L << While) | (1L << Alignas) | (1L << Alignof) | (1L << Atomic) | (1L << Bool) | (1L << Complex) | (1L << Noreturn) | (1L << ThreadLocal) | (1L << LeftParen))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (LeftBrace - 64)) | (1L << (Plus - 64)) | (1L << (PlusPlus - 64)) | (1L << (Minus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Star - 64)) | (1L << (And - 64)) | (1L << (Not - 64)) | (1L << (Tilde - 64)) | (1L << (Semi - 64)) | (1L << (Identifier - 64)) | (1L << (Constant - 64)) | (1L << (StringLiteral - 64)))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class BlockItemContext extends ParserRuleContext {
public BlockItemContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_blockItem; }
public BlockItemContext() { }
public void copyFrom(BlockItemContext ctx) {
super.copyFrom(ctx);
}
}
public static class BodyDeclarationContext extends BlockItemContext {
public DeclarationContext declaration() {
return getRuleContext(DeclarationContext.class,0);
}
public BodyDeclarationContext(BlockItemContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterBodyDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitBodyDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitBodyDeclaration(this);
else return visitor.visitChildren(this);
}
}
public static class BodyStatementContext extends BlockItemContext {
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public BodyStatementContext(BlockItemContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterBodyStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitBodyStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitBodyStatement(this);
else return visitor.visitChildren(this);
}
}
public final BlockItemContext blockItem() throws RecognitionException {
BlockItemContext _localctx = new BlockItemContext(_ctx, getState());
enterRule(_localctx, 168, RULE_blockItem);
try {
setState(956);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,113,_ctx) ) {
case 1:
_localctx = new BodyStatementContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(954);
statement();
}
break;
case 2:
_localctx = new BodyDeclarationContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(955);
declaration();
}
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 TerminalNode Semi() { return getToken(CParser.Semi, 0); }
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 CListener ) ((CListener)listener).enterExpressionStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitExpressionStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitExpressionStatement(this);
else return visitor.visitChildren(this);
}
}
public final ExpressionStatementContext expressionStatement() throws RecognitionException {
ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState());
enterRule(_localctx, 170, RULE_expressionStatement);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(959);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRETTY_FUNC) | (1L << Extension) | (1L << Sizeof) | (1L << Alignof) | (1L << LeftParen))) != 0) || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (Plus - 72)) | (1L << (PlusPlus - 72)) | (1L << (Minus - 72)) | (1L << (MinusMinus - 72)) | (1L << (Star - 72)) | (1L << (And - 72)) | (1L << (Not - 72)) | (1L << (Tilde - 72)) | (1L << (Identifier - 72)) | (1L << (Constant - 72)) | (1L << (StringLiteral - 72)))) != 0)) {
{
setState(958);
expression();
}
}
setState(961);
match(Semi);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SelectionStatementContext extends ParserRuleContext {
public SelectionStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_selectionStatement; }
public SelectionStatementContext() { }
public void copyFrom(SelectionStatementContext ctx) {
super.copyFrom(ctx);
}
}
public static class IfStatementContext extends SelectionStatementContext {
public TerminalNode If() { return getToken(CParser.If, 0); }
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public List statement() {
return getRuleContexts(StatementContext.class);
}
public StatementContext statement(int i) {
return getRuleContext(StatementContext.class,i);
}
public TerminalNode Else() { return getToken(CParser.Else, 0); }
public IfStatementContext(SelectionStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterIfStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitIfStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitIfStatement(this);
else return visitor.visitChildren(this);
}
}
public static class SwitchStatementContext extends SelectionStatementContext {
public TerminalNode Switch() { return getToken(CParser.Switch, 0); }
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public SwitchStatementContext(SelectionStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterSwitchStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitSwitchStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitSwitchStatement(this);
else return visitor.visitChildren(this);
}
}
public final SelectionStatementContext selectionStatement() throws RecognitionException {
SelectionStatementContext _localctx = new SelectionStatementContext(_ctx, getState());
enterRule(_localctx, 172, RULE_selectionStatement);
try {
setState(978);
_errHandler.sync(this);
switch (_input.LA(1)) {
case If:
_localctx = new IfStatementContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(963);
match(If);
setState(964);
match(LeftParen);
setState(965);
expression();
setState(966);
match(RightParen);
setState(967);
statement();
setState(970);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) {
case 1:
{
setState(968);
match(Else);
setState(969);
statement();
}
break;
}
}
break;
case Switch:
_localctx = new SwitchStatementContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(972);
match(Switch);
setState(973);
match(LeftParen);
setState(974);
expression();
setState(975);
match(RightParen);
setState(976);
statement();
}
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 IterationStatementContext extends ParserRuleContext {
public IterationStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_iterationStatement; }
public IterationStatementContext() { }
public void copyFrom(IterationStatementContext ctx) {
super.copyFrom(ctx);
}
}
public static class WhileStatementContext extends IterationStatementContext {
public TerminalNode While() { return getToken(CParser.While, 0); }
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public WhileStatementContext(IterationStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterWhileStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitWhileStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitWhileStatement(this);
else return visitor.visitChildren(this);
}
}
public static class ForStatementContext extends IterationStatementContext {
public TerminalNode For() { return getToken(CParser.For, 0); }
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public ForConditionContext forCondition() {
return getRuleContext(ForConditionContext.class,0);
}
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public ForStatementContext(IterationStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterForStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitForStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitForStatement(this);
else return visitor.visitChildren(this);
}
}
public static class DoWhileStatementContext extends IterationStatementContext {
public TerminalNode Do() { return getToken(CParser.Do, 0); }
public StatementContext statement() {
return getRuleContext(StatementContext.class,0);
}
public TerminalNode While() { return getToken(CParser.While, 0); }
public TerminalNode LeftParen() { return getToken(CParser.LeftParen, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public TerminalNode RightParen() { return getToken(CParser.RightParen, 0); }
public TerminalNode Semi() { return getToken(CParser.Semi, 0); }
public DoWhileStatementContext(IterationStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterDoWhileStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitDoWhileStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitDoWhileStatement(this);
else return visitor.visitChildren(this);
}
}
public final IterationStatementContext iterationStatement() throws RecognitionException {
IterationStatementContext _localctx = new IterationStatementContext(_ctx, getState());
enterRule(_localctx, 174, RULE_iterationStatement);
try {
setState(1000);
_errHandler.sync(this);
switch (_input.LA(1)) {
case While:
_localctx = new WhileStatementContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(980);
match(While);
setState(981);
match(LeftParen);
setState(982);
expression();
setState(983);
match(RightParen);
setState(984);
statement();
}
break;
case Do:
_localctx = new DoWhileStatementContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(986);
match(Do);
setState(987);
statement();
setState(988);
match(While);
setState(989);
match(LeftParen);
setState(990);
expression();
setState(991);
match(RightParen);
setState(992);
match(Semi);
}
break;
case For:
_localctx = new ForStatementContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(994);
match(For);
setState(995);
match(LeftParen);
setState(996);
forCondition();
setState(997);
match(RightParen);
setState(998);
statement();
}
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 ForConditionContext extends ParserRuleContext {
public ForInitContext forInit() {
return getRuleContext(ForInitContext.class,0);
}
public List Semi() { return getTokens(CParser.Semi); }
public TerminalNode Semi(int i) {
return getToken(CParser.Semi, i);
}
public ForTestContext forTest() {
return getRuleContext(ForTestContext.class,0);
}
public ForIncrContext forIncr() {
return getRuleContext(ForIncrContext.class,0);
}
public ForConditionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forCondition; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterForCondition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitForCondition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitForCondition(this);
else return visitor.visitChildren(this);
}
}
public final ForConditionContext forCondition() throws RecognitionException {
ForConditionContext _localctx = new ForConditionContext(_ctx, getState());
enterRule(_localctx, 176, RULE_forCondition);
try {
enterOuterAlt(_localctx, 1);
{
setState(1002);
forInit();
setState(1003);
match(Semi);
setState(1004);
forTest();
setState(1005);
match(Semi);
setState(1006);
forIncr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForInitContext extends ParserRuleContext {
public ForDeclarationContext forDeclaration() {
return getRuleContext(ForDeclarationContext.class,0);
}
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ForInitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forInit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterForInit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitForInit(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitForInit(this);
else return visitor.visitChildren(this);
}
}
public final ForInitContext forInit() throws RecognitionException {
ForInitContext _localctx = new ForInitContext(_ctx, getState());
enterRule(_localctx, 178, RULE_forInit);
int _la;
try {
setState(1012);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(1008);
forDeclaration();
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(1010);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRETTY_FUNC) | (1L << Extension) | (1L << Sizeof) | (1L << Alignof) | (1L << LeftParen))) != 0) || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (Plus - 72)) | (1L << (PlusPlus - 72)) | (1L << (Minus - 72)) | (1L << (MinusMinus - 72)) | (1L << (Star - 72)) | (1L << (And - 72)) | (1L << (Not - 72)) | (1L << (Tilde - 72)) | (1L << (Identifier - 72)) | (1L << (Constant - 72)) | (1L << (StringLiteral - 72)))) != 0)) {
{
setState(1009);
expression();
}
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForTestContext extends ParserRuleContext {
public ForExpressionContext forExpression() {
return getRuleContext(ForExpressionContext.class,0);
}
public ForTestContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forTest; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterForTest(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitForTest(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitForTest(this);
else return visitor.visitChildren(this);
}
}
public final ForTestContext forTest() throws RecognitionException {
ForTestContext _localctx = new ForTestContext(_ctx, getState());
enterRule(_localctx, 180, RULE_forTest);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1015);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRETTY_FUNC) | (1L << Extension) | (1L << Sizeof) | (1L << Alignof) | (1L << LeftParen))) != 0) || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (Plus - 72)) | (1L << (PlusPlus - 72)) | (1L << (Minus - 72)) | (1L << (MinusMinus - 72)) | (1L << (Star - 72)) | (1L << (And - 72)) | (1L << (Not - 72)) | (1L << (Tilde - 72)) | (1L << (Identifier - 72)) | (1L << (Constant - 72)) | (1L << (StringLiteral - 72)))) != 0)) {
{
setState(1014);
forExpression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForIncrContext extends ParserRuleContext {
public ForExpressionContext forExpression() {
return getRuleContext(ForExpressionContext.class,0);
}
public ForIncrContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forIncr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterForIncr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitForIncr(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitForIncr(this);
else return visitor.visitChildren(this);
}
}
public final ForIncrContext forIncr() throws RecognitionException {
ForIncrContext _localctx = new ForIncrContext(_ctx, getState());
enterRule(_localctx, 182, RULE_forIncr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1018);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRETTY_FUNC) | (1L << Extension) | (1L << Sizeof) | (1L << Alignof) | (1L << LeftParen))) != 0) || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (Plus - 72)) | (1L << (PlusPlus - 72)) | (1L << (Minus - 72)) | (1L << (MinusMinus - 72)) | (1L << (Star - 72)) | (1L << (And - 72)) | (1L << (Not - 72)) | (1L << (Tilde - 72)) | (1L << (Identifier - 72)) | (1L << (Constant - 72)) | (1L << (StringLiteral - 72)))) != 0)) {
{
setState(1017);
forExpression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForDeclarationContext extends ParserRuleContext {
public DeclarationSpecifiersContext declarationSpecifiers() {
return getRuleContext(DeclarationSpecifiersContext.class,0);
}
public InitDeclaratorListContext initDeclaratorList() {
return getRuleContext(InitDeclaratorListContext.class,0);
}
public ForDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forDeclaration; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterForDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitForDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitForDeclaration(this);
else return visitor.visitChildren(this);
}
}
public final ForDeclarationContext forDeclaration() throws RecognitionException {
ForDeclarationContext _localctx = new ForDeclarationContext(_ctx, getState());
enterRule(_localctx, 184, RULE_forDeclaration);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1020);
declarationSpecifiers();
setState(1022);
_errHandler.sync(this);
_la = _input.LA(1);
if (((((_la - 60)) & ~0x3f) == 0 && ((1L << (_la - 60)) & ((1L << (LeftParen - 60)) | (1L << (Star - 60)) | (1L << (Caret - 60)) | (1L << (Identifier - 60)))) != 0)) {
{
setState(1021);
initDeclaratorList();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ForExpressionContext extends ParserRuleContext {
public List assignmentExpression() {
return getRuleContexts(AssignmentExpressionContext.class);
}
public AssignmentExpressionContext assignmentExpression(int i) {
return getRuleContext(AssignmentExpressionContext.class,i);
}
public List Comma() { return getTokens(CParser.Comma); }
public TerminalNode Comma(int i) {
return getToken(CParser.Comma, i);
}
public ForExpressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_forExpression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterForExpression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitForExpression(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitForExpression(this);
else return visitor.visitChildren(this);
}
}
public final ForExpressionContext forExpression() throws RecognitionException {
ForExpressionContext _localctx = new ForExpressionContext(_ctx, getState());
enterRule(_localctx, 186, RULE_forExpression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1024);
assignmentExpression();
setState(1029);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==Comma) {
{
{
setState(1025);
match(Comma);
setState(1026);
assignmentExpression();
}
}
setState(1031);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
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 JumpStatementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_jumpStatement; }
public JumpStatementContext() { }
public void copyFrom(JumpStatementContext ctx) {
super.copyFrom(ctx);
}
}
public static class BreakStatementContext extends JumpStatementContext {
public TerminalNode Break() { return getToken(CParser.Break, 0); }
public BreakStatementContext(JumpStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterBreakStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitBreakStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitBreakStatement(this);
else return visitor.visitChildren(this);
}
}
public static class ContinueStatementContext extends JumpStatementContext {
public TerminalNode Continue() { return getToken(CParser.Continue, 0); }
public ContinueStatementContext(JumpStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterContinueStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitContinueStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitContinueStatement(this);
else return visitor.visitChildren(this);
}
}
public static class ReturnStatementContext extends JumpStatementContext {
public TerminalNode Return() { return getToken(CParser.Return, 0); }
public ExpressionContext expression() {
return getRuleContext(ExpressionContext.class,0);
}
public ReturnStatementContext(JumpStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterReturnStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitReturnStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitReturnStatement(this);
else return visitor.visitChildren(this);
}
}
public static class GotoStatementContext extends JumpStatementContext {
public TerminalNode Goto() { return getToken(CParser.Goto, 0); }
public TerminalNode Identifier() { return getToken(CParser.Identifier, 0); }
public GotoStatementContext(JumpStatementContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterGotoStatement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitGotoStatement(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitGotoStatement(this);
else return visitor.visitChildren(this);
}
}
public final JumpStatementContext jumpStatement() throws RecognitionException {
JumpStatementContext _localctx = new JumpStatementContext(_ctx, getState());
enterRule(_localctx, 188, RULE_jumpStatement);
int _la;
try {
setState(1040);
_errHandler.sync(this);
switch (_input.LA(1)) {
case Goto:
_localctx = new GotoStatementContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1032);
match(Goto);
setState(1033);
match(Identifier);
}
break;
case Continue:
_localctx = new ContinueStatementContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1034);
match(Continue);
}
break;
case Break:
_localctx = new BreakStatementContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1035);
match(Break);
}
break;
case Return:
_localctx = new ReturnStatementContext(_localctx);
enterOuterAlt(_localctx, 4);
{
setState(1036);
match(Return);
setState(1038);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << PRETTY_FUNC) | (1L << Extension) | (1L << Sizeof) | (1L << Alignof) | (1L << LeftParen))) != 0) || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (Plus - 72)) | (1L << (PlusPlus - 72)) | (1L << (Minus - 72)) | (1L << (MinusMinus - 72)) | (1L << (Star - 72)) | (1L << (And - 72)) | (1L << (Not - 72)) | (1L << (Tilde - 72)) | (1L << (Identifier - 72)) | (1L << (Constant - 72)) | (1L << (StringLiteral - 72)))) != 0)) {
{
setState(1037);
expression();
}
}
}
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 CompilationUnitContext extends ParserRuleContext {
public TerminalNode EOF() { return getToken(CParser.EOF, 0); }
public TranslationUnitContext translationUnit() {
return getRuleContext(TranslationUnitContext.class,0);
}
public CompilationUnitContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_compilationUnit; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterCompilationUnit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitCompilationUnit(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitCompilationUnit(this);
else return visitor.visitChildren(this);
}
}
public final CompilationUnitContext compilationUnit() throws RecognitionException {
CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState());
enterRule(_localctx, 190, RULE_compilationUnit);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1043);
_errHandler.sync(this);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__11) | (1L << Extension) | (1L << Auto) | (1L << Char) | (1L << Const) | (1L << Double) | (1L << Enum) | (1L << Extern) | (1L << Float) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Register) | (1L << Restrict) | (1L << Short) | (1L << Signed) | (1L << Static) | (1L << Struct) | (1L << Typedef) | (1L << Union) | (1L << Unsigned) | (1L << Void) | (1L << Volatile) | (1L << Alignas) | (1L << Atomic) | (1L << Bool) | (1L << Complex) | (1L << Noreturn) | (1L << ThreadLocal))) != 0) || _la==Semi || _la==Identifier) {
{
setState(1042);
translationUnit();
}
}
setState(1045);
match(EOF);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class TranslationUnitContext extends ParserRuleContext {
public List externalDeclaration() {
return getRuleContexts(ExternalDeclarationContext.class);
}
public ExternalDeclarationContext externalDeclaration(int i) {
return getRuleContext(ExternalDeclarationContext.class,i);
}
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 CListener ) ((CListener)listener).enterTranslationUnit(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitTranslationUnit(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitTranslationUnit(this);
else return visitor.visitChildren(this);
}
}
public final TranslationUnitContext translationUnit() throws RecognitionException {
TranslationUnitContext _localctx = new TranslationUnitContext(_ctx, getState());
enterRule(_localctx, 192, RULE_translationUnit);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(1048);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(1047);
externalDeclaration();
}
}
setState(1050);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__11) | (1L << Extension) | (1L << Auto) | (1L << Char) | (1L << Const) | (1L << Double) | (1L << Enum) | (1L << Extern) | (1L << Float) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Register) | (1L << Restrict) | (1L << Short) | (1L << Signed) | (1L << Static) | (1L << Struct) | (1L << Typedef) | (1L << Union) | (1L << Unsigned) | (1L << Void) | (1L << Volatile) | (1L << Alignas) | (1L << Atomic) | (1L << Bool) | (1L << Complex) | (1L << Noreturn) | (1L << ThreadLocal))) != 0) || _la==Semi || _la==Identifier );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExternalDeclarationContext extends ParserRuleContext {
public ExternalDeclarationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_externalDeclaration; }
public ExternalDeclarationContext() { }
public void copyFrom(ExternalDeclarationContext ctx) {
super.copyFrom(ctx);
}
}
public static class ExternalNopContext extends ExternalDeclarationContext {
public TerminalNode Semi() { return getToken(CParser.Semi, 0); }
public ExternalNopContext(ExternalDeclarationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterExternalNop(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitExternalNop(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitExternalNop(this);
else return visitor.visitChildren(this);
}
}
public static class GlobalDeclarationContext extends ExternalDeclarationContext {
public DeclarationContext declaration() {
return getRuleContext(DeclarationContext.class,0);
}
public GlobalDeclarationContext(ExternalDeclarationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterGlobalDeclaration(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitGlobalDeclaration(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitGlobalDeclaration(this);
else return visitor.visitChildren(this);
}
}
public static class ExternalFunctionDefinitionContext extends ExternalDeclarationContext {
public FunctionDefinitionContext functionDefinition() {
return getRuleContext(FunctionDefinitionContext.class,0);
}
public ExternalFunctionDefinitionContext(ExternalDeclarationContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).enterExternalFunctionDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitExternalFunctionDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitExternalFunctionDefinition(this);
else return visitor.visitChildren(this);
}
}
public final ExternalDeclarationContext externalDeclaration() throws RecognitionException {
ExternalDeclarationContext _localctx = new ExternalDeclarationContext(_ctx, getState());
enterRule(_localctx, 194, RULE_externalDeclaration);
try {
setState(1055);
_errHandler.sync(this);
switch ( getInterpreter().adaptivePredict(_input,128,_ctx) ) {
case 1:
_localctx = new ExternalFunctionDefinitionContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(1052);
functionDefinition();
}
break;
case 2:
_localctx = new GlobalDeclarationContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(1053);
declaration();
}
break;
case 3:
_localctx = new ExternalNopContext(_localctx);
enterOuterAlt(_localctx, 3);
{
setState(1054);
match(Semi);
}
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 DeclarationSpecifiersContext declarationSpecifiers() {
return getRuleContext(DeclarationSpecifiersContext.class,0);
}
public DeclaratorContext declarator() {
return getRuleContext(DeclaratorContext.class,0);
}
public CompoundStatementContext compoundStatement() {
return getRuleContext(CompoundStatementContext.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 CListener ) ((CListener)listener).enterFunctionDefinition(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof CListener ) ((CListener)listener).exitFunctionDefinition(this);
}
@Override
public T accept(ParseTreeVisitor visitor) {
if ( visitor instanceof CVisitor ) return ((CVisitor)visitor).visitFunctionDefinition(this);
else return visitor.visitChildren(this);
}
}
public final FunctionDefinitionContext functionDefinition() throws RecognitionException {
FunctionDefinitionContext _localctx = new FunctionDefinitionContext(_ctx, getState());
enterRule(_localctx, 196, RULE_functionDefinition);
try {
enterOuterAlt(_localctx, 1);
{
setState(1057);
declarationSpecifiers();
setState(1058);
declarator();
setState(1059);
compoundStatement();
}
}
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 41:
return typeSpecifier_sempred((TypeSpecifierContext)_localctx, predIndex);
case 60:
return directDeclarator_sempred((DirectDeclaratorContext)_localctx, predIndex);
case 73:
return directAbstractDeclarator_sempred((DirectAbstractDeclaratorContext)_localctx, predIndex);
}
return true;
}
private boolean typeSpecifier_sempred(TypeSpecifierContext _localctx, int predIndex) {
switch (predIndex) {
case 0:
return precpred(_ctx, 1);
}
return true;
}
private boolean directDeclarator_sempred(DirectDeclaratorContext _localctx, int predIndex) {
switch (predIndex) {
case 1:
return precpred(_ctx, 6);
case 2:
return precpred(_ctx, 5);
case 3:
return precpred(_ctx, 4);
case 4:
return precpred(_ctx, 3);
case 5:
return precpred(_ctx, 2);
}
return true;
}
private boolean directAbstractDeclarator_sempred(DirectAbstractDeclaratorContext _localctx, int predIndex) {
switch (predIndex) {
case 6:
return precpred(_ctx, 5);
case 7:
return precpred(_ctx, 4);
case 8:
return precpred(_ctx, 3);
case 9:
return precpred(_ctx, 2);
case 10:
return precpred(_ctx, 1);
}
return true;
}
public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3z\u0428\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\3\2\3\2\3\2\3\2\6\2\u00cd\n\2\r\2\16\2\u00ce"+
"\3\2\3\2\3\2\3\2\3\2\5\2\u00d6\n\2\3\2\3\2\3\2\3\2\5\2\u00dc\n\2\3\3\3"+
"\3\7\3\u00e0\n\3\f\3\16\3\u00e3\13\3\3\4\3\4\3\4\3\4\3\4\3\4\5\4\u00eb"+
"\n\4\3\5\3\5\3\5\3\5\3\6\3\6\5\6\u00f3\n\6\3\6\3\6\3\7\3\7\3\7\3\b\3\b"+
"\3\b\3\t\3\t\3\n\3\n\3\13\3\13\3\13\7\13\u0104\n\13\f\13\16\13\u0107\13"+
"\13\3\f\3\f\7\f\u010b\n\f\f\f\16\f\u010e\13\f\3\f\3\f\3\f\5\f\u0113\n"+
"\f\3\r\3\r\3\16\3\16\3\17\3\17\3\17\3\20\3\20\3\20\3\20\5\20\u0120\n\20"+
"\3\20\3\20\3\21\3\21\3\22\5\22\u0127\n\22\3\22\3\22\3\22\3\22\3\22\3\22"+
"\5\22\u012f\n\22\3\23\3\23\3\23\7\23\u0134\n\23\f\23\16\23\u0137\13\23"+
"\3\24\3\24\3\24\7\24\u013c\n\24\f\24\16\24\u013f\13\24\3\25\3\25\3\25"+
"\7\25\u0144\n\25\f\25\16\25\u0147\13\25\3\26\3\26\3\26\7\26\u014c\n\26"+
"\f\26\16\26\u014f\13\26\3\27\3\27\3\27\7\27\u0154\n\27\f\27\16\27\u0157"+
"\13\27\3\30\3\30\3\30\7\30\u015c\n\30\f\30\16\30\u015f\13\30\3\31\3\31"+
"\3\31\7\31\u0164\n\31\f\31\16\31\u0167\13\31\3\32\3\32\3\32\7\32\u016c"+
"\n\32\f\32\16\32\u016f\13\32\3\33\3\33\3\33\7\33\u0174\n\33\f\33\16\33"+
"\u0177\13\33\3\34\3\34\3\34\7\34\u017c\n\34\f\34\16\34\u017f\13\34\3\35"+
"\3\35\3\35\3\35\3\35\3\35\5\35\u0187\n\35\3\36\3\36\3\36\3\36\3\36\5\36"+
"\u018e\n\36\3\37\3\37\3 \3 \3 \7 \u0195\n \f \16 \u0198\13 \3!\3!\3\""+
"\3\"\5\"\u019e\n\"\3\"\3\"\3#\6#\u01a3\n#\r#\16#\u01a4\3$\6$\u01a8\n$"+
"\r$\16$\u01a9\3%\7%\u01ad\n%\f%\16%\u01b0\13%\3%\5%\u01b3\n%\3&\3&\3&"+
"\3&\3&\5&\u01ba\n&\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u01c2\n\'\3(\3(\3(\7(\u01c7"+
"\n(\f(\16(\u01ca\13(\3)\3)\3)\5)\u01cf\n)\3*\3*\3+\3+\3+\3+\3+\3+\3+\3"+
"+\3+\3+\3+\3+\3+\3+\3+\3+\3+\3+\5+\u01e5\n+\3+\3+\3+\3+\3+\3+\5+\u01ed"+
"\n+\3+\7+\u01f0\n+\f+\16+\u01f3\13+\3,\3,\3,\3-\3-\5-\u01fa\n-\3-\3-\3"+
"-\3-\3-\3-\3-\5-\u0203\n-\3.\3.\3/\6/\u0208\n/\r/\16/\u0209\3\60\3\60"+
"\5\60\u020e\n\60\3\60\3\60\3\61\6\61\u0213\n\61\r\61\16\61\u0214\3\61"+
"\3\61\3\61\6\61\u021a\n\61\r\61\16\61\u021b\5\61\u021e\n\61\3\62\3\62"+
"\5\62\u0222\n\62\3\63\3\63\3\63\7\63\u0227\n\63\f\63\16\63\u022a\13\63"+
"\3\64\3\64\5\64\u022e\n\64\3\64\3\64\5\64\u0232\n\64\3\65\3\65\5\65\u0236"+
"\n\65\3\65\3\65\3\65\5\65\u023b\n\65\3\65\3\65\3\65\3\65\5\65\u0241\n"+
"\65\3\66\3\66\3\66\7\66\u0246\n\66\f\66\16\66\u0249\13\66\3\67\3\67\3"+
"\67\5\67\u024e\n\67\38\38\39\39\39\39\39\3:\3:\3;\3;\3;\3;\3;\3;\5;\u025f"+
"\n;\3<\3<\3<\3<\5<\u0265\n<\3<\3<\3=\5=\u026a\n=\3=\3=\7=\u026e\n=\f="+
"\16=\u0271\13=\3>\3>\3>\3>\3>\3>\3>\3>\3>\5>\u027c\n>\3>\3>\3>\5>\u0281"+
"\n>\3>\5>\u0284\n>\3>\3>\3>\3>\3>\5>\u028b\n>\3>\3>\3>\3>\3>\3>\3>\3>"+
"\3>\3>\3>\3>\3>\5>\u029a\n>\3>\3>\3>\3>\3>\5>\u02a1\n>\3>\7>\u02a4\n>"+
"\f>\16>\u02a7\13>\3?\3?\3?\6?\u02ac\n?\r?\16?\u02ad\3?\3?\5?\u02b2\n?"+
"\3@\3@\3@\3@\3@\3@\3@\3A\5A\u02bc\nA\3A\3A\5A\u02c0\nA\7A\u02c2\nA\fA"+
"\16A\u02c5\13A\3B\3B\3B\5B\u02ca\nB\3B\5B\u02cd\nB\3C\3C\3C\3C\3C\7C\u02d4"+
"\nC\fC\16C\u02d7\13C\3D\3D\5D\u02db\nD\3D\5D\u02de\nD\3D\5D\u02e1\nD\6"+
"D\u02e3\nD\rD\16D\u02e4\3E\6E\u02e8\nE\rE\16E\u02e9\3F\3F\3F\5F\u02ef"+
"\nF\3G\3G\3G\7G\u02f4\nG\fG\16G\u02f7\13G\3H\3H\3H\3H\3H\5H\u02fe\nH\5"+
"H\u0300\nH\3I\3I\5I\u0304\nI\3J\3J\5J\u0308\nJ\3J\3J\7J\u030c\nJ\fJ\16"+
"J\u030f\13J\5J\u0311\nJ\3K\3K\3K\3K\3K\7K\u0318\nK\fK\16K\u031b\13K\3"+
"K\3K\5K\u031f\nK\3K\5K\u0322\nK\3K\3K\3K\3K\5K\u0328\nK\3K\3K\3K\3K\3"+
"K\3K\3K\3K\3K\3K\3K\3K\3K\3K\5K\u0338\nK\3K\3K\7K\u033c\nK\fK\16K\u033f"+
"\13K\5K\u0341\nK\3K\3K\3K\5K\u0346\nK\3K\5K\u0349\nK\3K\3K\3K\3K\3K\5"+
"K\u0350\nK\3K\3K\3K\3K\3K\3K\3K\3K\3K\3K\3K\3K\3K\3K\3K\3K\3K\5K\u0363"+
"\nK\3K\3K\7K\u0367\nK\fK\16K\u036a\13K\7K\u036c\nK\fK\16K\u036f\13K\3"+
"L\3L\3M\3M\3M\3M\5M\u0377\nM\3M\3M\5M\u037b\nM\3N\5N\u037e\nN\3N\3N\3"+
"N\5N\u0383\nN\3N\7N\u0386\nN\fN\16N\u0389\13N\3O\3O\3O\3P\6P\u038f\nP"+
"\rP\16P\u0390\3Q\3Q\3Q\3Q\3Q\3Q\5Q\u0399\nQ\3R\3R\3R\3R\3R\3R\3R\3R\5"+
"R\u03a3\nR\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\5S\u03b0\nS\3T\3T\5T\u03b4"+
"\nT\3T\3T\3U\6U\u03b9\nU\rU\16U\u03ba\3V\3V\5V\u03bf\nV\3W\5W\u03c2\n"+
"W\3W\3W\3X\3X\3X\3X\3X\3X\3X\5X\u03cd\nX\3X\3X\3X\3X\3X\3X\5X\u03d5\n"+
"X\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\5Y\u03eb"+
"\nY\3Z\3Z\3Z\3Z\3Z\3Z\3[\3[\5[\u03f5\n[\5[\u03f7\n[\3\\\5\\\u03fa\n\\"+
"\3]\5]\u03fd\n]\3^\3^\5^\u0401\n^\3_\3_\3_\7_\u0406\n_\f_\16_\u0409\13"+
"_\3`\3`\3`\3`\3`\3`\5`\u0411\n`\5`\u0413\n`\3a\5a\u0416\na\3a\3a\3b\6"+
"b\u041b\nb\rb\16b\u041c\3c\3c\3c\5c\u0422\nc\3d\3d\3d\3d\3d\2\5Tz\u0094"+
"e\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDF"+
"HJLNPRTVXZ\\^`bdfhjlnprtvxz|~\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\2\23\4\2**\65\65\7\2JJLLNNQQVW\3\2NP\4"+
"\2JJLL\3\2HI\3\2DG\3\2gh\3\2\\f\b\2\22\22\35\35%%++..==\b\2\3\6\25\25"+
"#$()\60\61\678\3\2\4\6\4\2,,//\6\2\26\26&&\62\62\66\66\5\2\t\n\"\";;\3"+
"\2\f\r\4\2>?[[\3\2>?\2\u0472\2\u00db\3\2\2\2\4\u00dd\3\2\2\2\6\u00ea\3"+
"\2\2\2\b\u00ec\3\2\2\2\n\u00f0\3\2\2\2\f\u00f6\3\2\2\2\16\u00f9\3\2\2"+
"\2\20\u00fc\3\2\2\2\22\u00fe\3\2\2\2\24\u0100\3\2\2\2\26\u010c\3\2\2\2"+
"\30\u0114\3\2\2\2\32\u0116\3\2\2\2\34\u0118\3\2\2\2\36\u011b\3\2\2\2 "+
"\u0123\3\2\2\2\"\u012e\3\2\2\2$\u0130\3\2\2\2&\u0138\3\2\2\2(\u0140\3"+
"\2\2\2*\u0148\3\2\2\2,\u0150\3\2\2\2.\u0158\3\2\2\2\60\u0160\3\2\2\2\62"+
"\u0168\3\2\2\2\64\u0170\3\2\2\2\66\u0178\3\2\2\28\u0180\3\2\2\2:\u018d"+
"\3\2\2\2<\u018f\3\2\2\2>\u0191\3\2\2\2@\u0199\3\2\2\2B\u019b\3\2\2\2D"+
"\u01a2\3\2\2\2F\u01a7\3\2\2\2H\u01ae\3\2\2\2J\u01b9\3\2\2\2L\u01c1\3\2"+
"\2\2N\u01c3\3\2\2\2P\u01cb\3\2\2\2R\u01d0\3\2\2\2T\u01e4\3\2\2\2V\u01f4"+
"\3\2\2\2X\u0202\3\2\2\2Z\u0204\3\2\2\2\\\u0207\3\2\2\2^\u020b\3\2\2\2"+
"`\u021d\3\2\2\2b\u0221\3\2\2\2d\u0223\3\2\2\2f\u0231\3\2\2\2h\u0240\3"+
"\2\2\2j\u0242\3\2\2\2l\u024a\3\2\2\2n\u024f\3\2\2\2p\u0251\3\2\2\2r\u0256"+
"\3\2\2\2t\u025e\3\2\2\2v\u0260\3\2\2\2x\u0269\3\2\2\2z\u027b\3\2\2\2|"+
"\u02b1\3\2\2\2~\u02b3\3\2\2\2\u0080\u02bb\3\2\2\2\u0082\u02c6\3\2\2\2"+
"\u0084\u02d5\3\2\2\2\u0086\u02e2\3\2\2\2\u0088\u02e7\3\2\2\2\u008a\u02eb"+
"\3\2\2\2\u008c\u02f0\3\2\2\2\u008e\u02ff\3\2\2\2\u0090\u0301\3\2\2\2\u0092"+
"\u0310\3\2\2\2\u0094\u0340\3\2\2\2\u0096\u0370\3\2\2\2\u0098\u037a\3\2"+
"\2\2\u009a\u037d\3\2\2\2\u009c\u038a\3\2\2\2\u009e\u038e\3\2\2\2\u00a0"+
"\u0398\3\2\2\2\u00a2\u03a2\3\2\2\2\u00a4\u03af\3\2\2\2\u00a6\u03b1\3\2"+
"\2\2\u00a8\u03b8\3\2\2\2\u00aa\u03be\3\2\2\2\u00ac\u03c1\3\2\2\2\u00ae"+
"\u03d4\3\2\2\2\u00b0\u03ea\3\2\2\2\u00b2\u03ec\3\2\2\2\u00b4\u03f6\3\2"+
"\2\2\u00b6\u03f9\3\2\2\2\u00b8\u03fc\3\2\2\2\u00ba\u03fe\3\2\2\2\u00bc"+
"\u0402\3\2\2\2\u00be\u0412\3\2\2\2\u00c0\u0415\3\2\2\2\u00c2\u041a\3\2"+
"\2\2\u00c4\u0421\3\2\2\2\u00c6\u0423\3\2\2\2\u00c8\u00dc\7\20\2\2\u00c9"+
"\u00dc\7l\2\2\u00ca\u00dc\7m\2\2\u00cb\u00cd\7o\2\2\u00cc\u00cb\3\2\2"+
"\2\u00cd\u00ce\3\2\2\2\u00ce\u00cc\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cf\u00dc"+
"\3\2\2\2\u00d0\u00d1\7>\2\2\u00d1\u00d2\5> \2\u00d2\u00d3\7?\2\2\u00d3"+
"\u00dc\3\2\2\2\u00d4\u00d6\7\21\2\2\u00d5\u00d4\3\2\2\2\u00d5\u00d6\3"+
"\2\2\2\u00d6\u00d7\3\2\2\2\u00d7\u00d8\7>\2\2\u00d8\u00d9\5\u00a6T\2\u00d9"+
"\u00da\7?\2\2\u00da\u00dc\3\2\2\2\u00db\u00c8\3\2\2\2\u00db\u00c9\3\2"+
"\2\2\u00db\u00ca\3\2\2\2\u00db\u00cc\3\2\2\2\u00db\u00d0\3\2\2\2\u00db"+
"\u00d5\3\2\2\2\u00dc\3\3\2\2\2\u00dd\u00e1\5\2\2\2\u00de\u00e0\5\6\4\2"+
"\u00df\u00de\3\2\2\2\u00e0\u00e3\3\2\2\2\u00e1\u00df\3\2\2\2\u00e1\u00e2"+
"\3\2\2\2\u00e2\5\3\2\2\2\u00e3\u00e1\3\2\2\2\u00e4\u00eb\5\b\5\2\u00e5"+
"\u00eb\5\n\6\2\u00e6\u00eb\5\f\7\2\u00e7\u00eb\5\16\b\2\u00e8\u00eb\5"+
"\20\t\2\u00e9\u00eb\5\22\n\2\u00ea\u00e4\3\2\2\2\u00ea\u00e5\3\2\2\2\u00ea"+
"\u00e6\3\2\2\2\u00ea\u00e7\3\2\2\2\u00ea\u00e8\3\2\2\2\u00ea\u00e9\3\2"+
"\2\2\u00eb\7\3\2\2\2\u00ec\u00ed\7@\2\2\u00ed\u00ee\5> \2\u00ee\u00ef"+
"\7A\2\2\u00ef\t\3\2\2\2\u00f0\u00f2\7>\2\2\u00f1\u00f3\5\24\13\2\u00f2"+
"\u00f1\3\2\2\2\u00f2\u00f3\3\2\2\2\u00f3\u00f4\3\2\2\2\u00f4\u00f5\7?"+
"\2\2\u00f5\13\3\2\2\2\u00f6\u00f7\7j\2\2\u00f7\u00f8\7l\2\2\u00f8\r\3"+
"\2\2\2\u00f9\u00fa\7i\2\2\u00fa\u00fb\7l\2\2\u00fb\17\3\2\2\2\u00fc\u00fd"+
"\7K\2\2\u00fd\21\3\2\2\2\u00fe\u00ff\7M\2\2\u00ff\23\3\2\2\2\u0100\u0105"+
"\5:\36\2\u0101\u0102\7[\2\2\u0102\u0104\5:\36\2\u0103\u0101\3\2\2\2\u0104"+
"\u0107\3\2\2\2\u0105\u0103\3\2\2\2\u0105\u0106\3\2\2\2\u0106\25\3\2\2"+
"\2\u0107\u0105\3\2\2\2\u0108\u010b\5\30\r\2\u0109\u010b\5\32\16\2\u010a"+
"\u0108\3\2\2\2\u010a\u0109\3\2\2\2\u010b\u010e\3\2\2\2\u010c\u010a\3\2"+
"\2\2\u010c\u010d\3\2\2\2\u010d\u0112\3\2\2\2\u010e\u010c\3\2\2\2\u010f"+
"\u0113\5\4\3\2\u0110\u0113\5\34\17\2\u0111\u0113\5\36\20\2\u0112\u010f"+
"\3\2\2\2\u0112\u0110\3\2\2\2\u0112\u0111\3\2\2\2\u0113\27\3\2\2\2\u0114"+
"\u0115\7K\2\2\u0115\31\3\2\2\2\u0116\u0117\7M\2\2\u0117\33\3\2\2\2\u0118"+
"\u0119\5 \21\2\u0119\u011a\5\"\22\2\u011a\35\3\2\2\2\u011b\u011c\t\2\2"+
"\2\u011c\u011f\7>\2\2\u011d\u0120\5\u0090I\2\u011e\u0120\5> \2\u011f\u011d"+
"\3\2\2\2\u011f\u011e\3\2\2\2\u0120\u0121\3\2\2\2\u0121\u0122\7?\2\2\u0122"+
"\37\3\2\2\2\u0123\u0124\t\3\2\2\u0124!\3\2\2\2\u0125\u0127\7\21\2\2\u0126"+
"\u0125\3\2\2\2\u0126\u0127\3\2\2\2\u0127\u0128\3\2\2\2\u0128\u0129\7>"+
"\2\2\u0129\u012a\5H%\2\u012a\u012b\7?\2\2\u012b\u012c\5\"\22\2\u012c\u012f"+
"\3\2\2\2\u012d\u012f\5\26\f\2\u012e\u0126\3\2\2\2\u012e\u012d\3\2\2\2"+
"\u012f#\3\2\2\2\u0130\u0135\5\"\22\2\u0131\u0132\t\4\2\2\u0132\u0134\5"+
"\"\22\2\u0133\u0131\3\2\2\2\u0134\u0137\3\2\2\2\u0135\u0133\3\2\2\2\u0135"+
"\u0136\3\2\2\2\u0136%\3\2\2\2\u0137\u0135\3\2\2\2\u0138\u013d\5$\23\2"+
"\u0139\u013a\t\5\2\2\u013a\u013c\5$\23\2\u013b\u0139\3\2\2\2\u013c\u013f"+
"\3\2\2\2\u013d\u013b\3\2\2\2\u013d\u013e\3\2\2\2\u013e\'\3\2\2\2\u013f"+
"\u013d\3\2\2\2\u0140\u0145\5&\24\2\u0141\u0142\t\6\2\2\u0142\u0144\5&"+
"\24\2\u0143\u0141\3\2\2\2\u0144\u0147\3\2\2\2\u0145\u0143\3\2\2\2\u0145"+
"\u0146\3\2\2\2\u0146)\3\2\2\2\u0147\u0145\3\2\2\2\u0148\u014d\5(\25\2"+
"\u0149\u014a\t\7\2\2\u014a\u014c\5(\25\2\u014b\u0149\3\2\2\2\u014c\u014f"+
"\3\2\2\2\u014d\u014b\3\2\2\2\u014d\u014e\3\2\2\2\u014e+\3\2\2\2\u014f"+
"\u014d\3\2\2\2\u0150\u0155\5*\26\2\u0151\u0152\t\b\2\2\u0152\u0154\5*"+
"\26\2\u0153\u0151\3\2\2\2\u0154\u0157\3\2\2\2\u0155\u0153\3\2\2\2\u0155"+
"\u0156\3\2\2\2\u0156-\3\2\2\2\u0157\u0155\3\2\2\2\u0158\u015d\5,\27\2"+
"\u0159\u015a\7Q\2\2\u015a\u015c\5,\27\2\u015b\u0159\3\2\2\2\u015c\u015f"+
"\3\2\2\2\u015d\u015b\3\2\2\2\u015d\u015e\3\2\2\2\u015e/\3\2\2\2\u015f"+
"\u015d\3\2\2\2\u0160\u0165\5.\30\2\u0161\u0162\7U\2\2\u0162\u0164\5.\30"+
"\2\u0163\u0161\3\2\2\2\u0164\u0167\3\2\2\2\u0165\u0163\3\2\2\2\u0165\u0166"+
"\3\2\2\2\u0166\61\3\2\2\2\u0167\u0165\3\2\2\2\u0168\u016d\5\60\31\2\u0169"+
"\u016a\7R\2\2\u016a\u016c\5\60\31\2\u016b\u0169\3\2\2\2\u016c\u016f\3"+
"\2\2\2\u016d\u016b\3\2\2\2\u016d\u016e\3\2\2\2\u016e\63\3\2\2\2\u016f"+
"\u016d\3\2\2\2\u0170\u0175\5\62\32\2\u0171\u0172\7S\2\2\u0172\u0174\5"+
"\62\32\2\u0173\u0171\3\2\2\2\u0174\u0177\3\2\2\2\u0175\u0173\3\2\2\2\u0175"+
"\u0176\3\2\2\2\u0176\65\3\2\2\2\u0177\u0175\3\2\2\2\u0178\u017d\5\64\33"+
"\2\u0179\u017a\7T\2\2\u017a\u017c\5\64\33\2\u017b\u0179\3\2\2\2\u017c"+
"\u017f\3\2\2\2\u017d\u017b\3\2\2\2\u017d\u017e\3\2\2\2\u017e\67\3\2\2"+
"\2\u017f\u017d\3\2\2\2\u0180\u0186\5\66\34\2\u0181\u0182\7X\2\2\u0182"+
"\u0183\5> \2\u0183\u0184\7Y\2\2\u0184\u0185\58\35\2\u0185\u0187\3\2\2"+
"\2\u0186\u0181\3\2\2\2\u0186\u0187\3\2\2\2\u01879\3\2\2\2\u0188\u018e"+
"\58\35\2\u0189\u018a\5\26\f\2\u018a\u018b\5<\37\2\u018b\u018c\5:\36\2"+
"\u018c\u018e\3\2\2\2\u018d\u0188\3\2\2\2\u018d\u0189\3\2\2\2\u018e;\3"+
"\2\2\2\u018f\u0190\t\t\2\2\u0190=\3\2\2\2\u0191\u0196\5:\36\2\u0192\u0193"+
"\7[\2\2\u0193\u0195\5:\36\2\u0194\u0192\3\2\2\2\u0195\u0198\3\2\2\2\u0196"+
"\u0194\3\2\2\2\u0196\u0197\3\2\2\2\u0197?\3\2\2\2\u0198\u0196\3\2\2\2"+
"\u0199\u019a\58\35\2\u019aA\3\2\2\2\u019b\u019d\5D#\2\u019c\u019e\5N("+
"\2\u019d\u019c\3\2\2\2\u019d\u019e\3\2\2\2\u019e\u019f\3\2\2\2\u019f\u01a0"+
"\7Z\2\2\u01a0C\3\2\2\2\u01a1\u01a3\5L\'\2\u01a2\u01a1\3\2\2\2\u01a3\u01a4"+
"\3\2\2\2\u01a4\u01a2\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5E\3\2\2\2\u01a6"+
"\u01a8\5L\'\2\u01a7\u01a6\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01a7\3\2"+
"\2\2\u01a9\u01aa\3\2\2\2\u01aaG\3\2\2\2\u01ab\u01ad\5J&\2\u01ac\u01ab"+
"\3\2\2\2\u01ad\u01b0\3\2\2\2\u01ae\u01ac\3\2\2\2\u01ae\u01af\3\2\2\2\u01af"+
"\u01b2\3\2\2\2\u01b0\u01ae\3\2\2\2\u01b1\u01b3\5V,\2\u01b2\u01b1\3\2\2"+
"\2\u01b2\u01b3\3\2\2\2\u01b3I\3\2\2\2\u01b4\u01ba\5R*\2\u01b5\u01ba\5"+
"T+\2\u01b6\u01ba\5r:\2\u01b7\u01ba\5t;\2\u01b8\u01ba\5v<\2\u01b9\u01b4"+
"\3\2\2\2\u01b9\u01b5\3\2\2\2\u01b9\u01b6\3\2\2\2\u01b9\u01b7\3\2\2\2\u01b9"+
"\u01b8\3\2\2\2\u01baK\3\2\2\2\u01bb\u01c2\5R*\2\u01bc\u01c2\5V,\2\u01bd"+
"\u01c2\5T+\2\u01be\u01c2\5r:\2\u01bf\u01c2\5t;\2\u01c0\u01c2\5v<\2\u01c1"+
"\u01bb\3\2\2\2\u01c1\u01bc\3\2\2\2\u01c1\u01bd\3\2\2\2\u01c1\u01be\3\2"+
"\2\2\u01c1\u01bf\3\2\2\2\u01c1\u01c0\3\2\2\2\u01c2M\3\2\2\2\u01c3\u01c8"+
"\5P)\2\u01c4\u01c5\7[\2\2\u01c5\u01c7\5P)\2\u01c6\u01c4\3\2\2\2\u01c7"+
"\u01ca\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c8\u01c9\3\2\2\2\u01c9O\3\2\2\2"+
"\u01ca\u01c8\3\2\2\2\u01cb\u01ce\5x=\2\u01cc\u01cd\7\\\2\2\u01cd\u01cf"+
"\5\u0098M\2\u01ce\u01cc\3\2\2\2\u01ce\u01cf\3\2\2\2\u01cfQ\3\2\2\2\u01d0"+
"\u01d1\t\n\2\2\u01d1S\3\2\2\2\u01d2\u01d3\b+\1\2\u01d3\u01e5\t\13\2\2"+
"\u01d4\u01e5\7\7\2\2\u01d5\u01e5\7\36\2\2\u01d6\u01e5\7\32\2\2\u01d7\u01d8"+
"\7\21\2\2\u01d8\u01d9\7>\2\2\u01d9\u01da\t\f\2\2\u01da\u01e5\7?\2\2\u01db"+
"\u01e5\5p9\2\u01dc\u01e5\5X-\2\u01dd\u01e5\5h\65\2\u01de\u01e5\5\u0096"+
"L\2\u01df\u01e0\7\b\2\2\u01e0\u01e1\7>\2\2\u01e1\u01e2\5@!\2\u01e2\u01e3"+
"\7?\2\2\u01e3\u01e5\3\2\2\2\u01e4\u01d2\3\2\2\2\u01e4\u01d4\3\2\2\2\u01e4"+
"\u01d5\3\2\2\2\u01e4\u01d6\3\2\2\2\u01e4\u01d7\3\2\2\2\u01e4\u01db\3\2"+
"\2\2\u01e4\u01dc\3\2\2\2\u01e4\u01dd\3\2\2\2\u01e4\u01de\3\2\2\2\u01e4"+
"\u01df\3\2\2\2\u01e5\u01f1\3\2\2\2\u01e6\u01e7\f\3\2\2\u01e7\u01e8\7>"+
"\2\2\u01e8\u01e9\7N\2\2\u01e9\u01ea\7?\2\2\u01ea\u01ec\7>\2\2\u01eb\u01ed"+
"\5\u008aF\2\u01ec\u01eb\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01ee\3\2\2"+
"\2\u01ee\u01f0\7?\2\2\u01ef\u01e6\3\2\2\2\u01f0\u01f3\3\2\2\2\u01f1\u01ef"+
"\3\2\2\2\u01f1\u01f2\3\2\2\2\u01f2U\3\2\2\2\u01f3\u01f1\3\2\2\2\u01f4"+
"\u01f5\5T+\2\u01f5\u01f6\5\u0086D\2\u01f6W\3\2\2\2\u01f7\u01f9\5Z.\2\u01f8"+
"\u01fa\7l\2\2\u01f9\u01f8\3\2\2\2\u01f9\u01fa\3\2\2\2\u01fa\u01fb\3\2"+
"\2\2\u01fb\u01fc\7B\2\2\u01fc\u01fd\5\\/\2\u01fd\u01fe\7C\2\2\u01fe\u0203"+
"\3\2\2\2\u01ff\u0200\5Z.\2\u0200\u0201\7l\2\2\u0201\u0203\3\2\2\2\u0202"+
"\u01f7\3\2\2\2\u0202\u01ff\3\2\2\2\u0203Y\3\2\2\2\u0204\u0205\t\r\2\2"+
"\u0205[\3\2\2\2\u0206\u0208\5^\60\2\u0207\u0206\3\2\2\2\u0208\u0209\3"+
"\2\2\2\u0209\u0207\3\2\2\2\u0209\u020a\3\2\2\2\u020a]\3\2\2\2\u020b\u020d"+
"\5`\61\2\u020c\u020e\5d\63\2\u020d\u020c\3\2\2\2\u020d\u020e\3\2\2\2\u020e"+
"\u020f\3\2\2\2\u020f\u0210\7Z\2\2\u0210_\3\2\2\2\u0211\u0213\5b\62\2\u0212"+
"\u0211\3\2\2\2\u0213\u0214\3\2\2\2\u0214\u0212\3\2\2\2\u0214\u0215\3\2"+
"\2\2\u0215\u0216\3\2\2\2\u0216\u0217\5V,\2\u0217\u021e\3\2\2\2\u0218\u021a"+
"\5b\62\2\u0219\u0218\3\2\2\2\u021a\u021b\3\2\2\2\u021b\u0219\3\2\2\2\u021b"+
"\u021c\3\2\2\2\u021c\u021e\3\2\2\2\u021d\u0212\3\2\2\2\u021d\u0219\3\2"+
"\2\2\u021ea\3\2\2\2\u021f\u0222\5T+\2\u0220\u0222\5r:\2\u0221\u021f\3"+
"\2\2\2\u0221\u0220\3\2\2\2\u0222c\3\2\2\2\u0223\u0228\5f\64\2\u0224\u0225"+
"\7[\2\2\u0225\u0227\5f\64\2\u0226\u0224\3\2\2\2\u0227\u022a\3\2\2\2\u0228"+
"\u0226\3\2\2\2\u0228\u0229\3\2\2\2\u0229e\3\2\2\2\u022a\u0228\3\2\2\2"+
"\u022b\u0232\5x=\2\u022c\u022e\5x=\2\u022d\u022c\3\2\2\2\u022d\u022e\3"+
"\2\2\2\u022e\u022f\3\2\2\2\u022f\u0230\7Y\2\2\u0230\u0232\5@!\2\u0231"+
"\u022b\3\2\2\2\u0231\u022d\3\2\2\2\u0232g\3\2\2\2\u0233\u0235\7\34\2\2"+
"\u0234\u0236\7l\2\2\u0235\u0234\3\2\2\2\u0235\u0236\3\2\2\2\u0236\u0237"+
"\3\2\2\2\u0237\u0238\7B\2\2\u0238\u023a\5j\66\2\u0239\u023b\7[\2\2\u023a"+
"\u0239\3\2\2\2\u023a\u023b\3\2\2\2\u023b\u023c\3\2\2\2\u023c\u023d\7C"+
"\2\2\u023d\u0241\3\2\2\2\u023e\u023f\7\34\2\2\u023f\u0241\7l\2\2\u0240"+
"\u0233\3\2\2\2\u0240\u023e\3\2\2\2\u0241i\3\2\2\2\u0242\u0247\5l\67\2"+
"\u0243\u0244\7[\2\2\u0244\u0246\5l\67\2\u0245\u0243\3\2\2\2\u0246\u0249"+
"\3\2\2\2\u0247\u0245\3\2\2\2\u0247\u0248\3\2\2\2\u0248k\3\2\2\2\u0249"+
"\u0247\3\2\2\2\u024a\u024d\5n8\2\u024b\u024c\7\\\2\2\u024c\u024e\5@!\2"+
"\u024d\u024b\3\2\2\2\u024d\u024e\3\2\2\2\u024em\3\2\2\2\u024f\u0250\7"+
"l\2\2\u0250o\3\2\2\2\u0251\u0252\7\66\2\2\u0252\u0253\7>\2\2\u0253\u0254"+
"\5\u0090I\2\u0254\u0255\7?\2\2\u0255q\3\2\2\2\u0256\u0257\t\16\2\2\u0257"+
"s\3\2\2\2\u0258\u025f\t\17\2\2\u0259\u025f\5~@\2\u025a\u025b\7\13\2\2"+
"\u025b\u025c\7>\2\2\u025c\u025d\7l\2\2\u025d\u025f\7?\2\2\u025e\u0258"+
"\3\2\2\2\u025e\u0259\3\2\2\2\u025e\u025a\3\2\2\2\u025fu\3\2\2\2\u0260"+
"\u0261\7\64\2\2\u0261\u0264\7>\2\2\u0262\u0265\5\u0090I\2\u0263\u0265"+
"\5@!\2\u0264\u0262\3\2\2\2\u0264\u0263\3\2\2\2\u0265\u0266\3\2\2\2\u0266"+
"\u0267\7?\2\2\u0267w\3\2\2\2\u0268\u026a\5\u0086D\2\u0269\u0268\3\2\2"+
"\2\u0269\u026a\3\2\2\2\u026a\u026b\3\2\2\2\u026b\u026f\5z>\2\u026c\u026e"+
"\5|?\2\u026d\u026c\3\2\2\2\u026e\u0271\3\2\2\2\u026f\u026d\3\2\2\2\u026f"+
"\u0270\3\2\2\2\u0270y\3\2\2\2\u0271\u026f\3\2\2\2\u0272\u0273\b>\1\2\u0273"+
"\u027c\7l\2\2\u0274\u0275\7>\2\2\u0275\u0276\5x=\2\u0276\u0277\7?\2\2"+
"\u0277\u027c\3\2\2\2\u0278\u0279\7l\2\2\u0279\u027a\7Y\2\2\u027a\u027c"+
"\7n\2\2\u027b\u0272\3\2\2\2\u027b\u0274\3\2\2\2\u027b\u0278\3\2\2\2\u027c"+
"\u02a5\3\2\2\2\u027d\u027e\f\b\2\2\u027e\u0280\7@\2\2\u027f\u0281\5\u0088"+
"E\2\u0280\u027f\3\2\2\2\u0280\u0281\3\2\2\2\u0281\u0283\3\2\2\2\u0282"+
"\u0284\5:\36\2\u0283\u0282\3\2\2\2\u0283\u0284\3\2\2\2\u0284\u0285\3\2"+
"\2\2\u0285\u02a4\7A\2\2\u0286\u0287\f\7\2\2\u0287\u0288\7@\2\2\u0288\u028a"+
"\7+\2\2\u0289\u028b\5\u0088E\2\u028a\u0289\3\2\2\2\u028a\u028b\3\2\2\2"+
"\u028b\u028c\3\2\2\2\u028c\u028d\5:\36\2\u028d\u028e\7A\2\2\u028e\u02a4"+
"\3\2\2\2\u028f\u0290\f\6\2\2\u0290\u0291\7@\2\2\u0291\u0292\5\u0088E\2"+
"\u0292\u0293\7+\2\2\u0293\u0294\5:\36\2\u0294\u0295\7A\2\2\u0295\u02a4"+
"\3\2\2\2\u0296\u0297\f\5\2\2\u0297\u0299\7@\2\2\u0298\u029a\5\u0088E\2"+
"\u0299\u0298\3\2\2\2\u0299\u029a\3\2\2\2\u029a\u029b\3\2\2\2\u029b\u029c"+
"\7N\2\2\u029c\u02a4\7A\2\2\u029d\u029e\f\4\2\2\u029e\u02a0\7>\2\2\u029f"+
"\u02a1\5\u008aF\2\u02a0\u029f\3\2\2\2\u02a0\u02a1\3\2\2\2\u02a1\u02a2"+
"\3\2\2\2\u02a2\u02a4\7?\2\2\u02a3\u027d\3\2\2\2\u02a3\u0286\3\2\2\2\u02a3"+
"\u028f\3\2\2\2\u02a3\u0296\3\2\2\2\u02a3\u029d\3\2\2\2\u02a4\u02a7\3\2"+
"\2\2\u02a5\u02a3\3\2\2\2\u02a5\u02a6\3\2\2\2\u02a6{\3\2\2\2\u02a7\u02a5"+
"\3\2\2\2\u02a8\u02a9\t\20\2\2\u02a9\u02ab\7>\2\2\u02aa\u02ac\7o\2\2\u02ab"+
"\u02aa\3\2\2\2\u02ac\u02ad\3\2\2\2\u02ad\u02ab\3\2\2\2\u02ad\u02ae\3\2"+
"\2\2\u02ae\u02af\3\2\2\2\u02af\u02b2\7?\2\2\u02b0\u02b2\5~@\2\u02b1\u02a8"+
"\3\2\2\2\u02b1\u02b0\3\2\2\2\u02b2}\3\2\2\2\u02b3\u02b4\7\16\2\2\u02b4"+
"\u02b5\7>\2\2\u02b5\u02b6\7>\2\2\u02b6\u02b7\5\u0080A\2\u02b7\u02b8\7"+
"?\2\2\u02b8\u02b9\7?\2\2\u02b9\177\3\2\2\2\u02ba\u02bc\5\u0082B\2\u02bb"+
"\u02ba\3\2\2\2\u02bb\u02bc\3\2\2\2\u02bc\u02c3\3\2\2\2\u02bd\u02bf\7["+
"\2\2\u02be\u02c0\5\u0082B\2\u02bf\u02be\3\2\2\2\u02bf\u02c0\3\2\2\2\u02c0"+
"\u02c2\3\2\2\2\u02c1\u02bd\3\2\2\2\u02c2\u02c5\3\2\2\2\u02c3\u02c1\3\2"+
"\2\2\u02c3\u02c4\3\2\2\2\u02c4\u0081\3\2\2\2\u02c5\u02c3\3\2\2\2\u02c6"+
"\u02cc\n\21\2\2\u02c7\u02c9\7>\2\2\u02c8\u02ca\5\24\13\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"+
"\u02c7\3\2\2\2\u02cc\u02cd\3\2\2\2\u02cd\u0083\3\2\2\2\u02ce\u02d4\n\22"+
"\2\2\u02cf\u02d0\7>\2\2\u02d0\u02d1\5\u0084C\2\u02d1\u02d2\7?\2\2\u02d2"+
"\u02d4\3\2\2\2\u02d3\u02ce\3\2\2\2\u02d3\u02cf\3\2\2\2\u02d4\u02d7\3\2"+
"\2\2\u02d5\u02d3\3\2\2\2\u02d5\u02d6\3\2\2\2\u02d6\u0085\3\2\2\2\u02d7"+
"\u02d5\3\2\2\2\u02d8\u02db\7N\2\2\u02d9\u02db\7U\2\2\u02da\u02d8\3\2\2"+
"\2\u02da\u02d9\3\2\2\2\u02db\u02dd\3\2\2\2\u02dc\u02de\7\17\2\2\u02dd"+
"\u02dc\3\2\2\2\u02dd\u02de\3\2\2\2\u02de\u02e0\3\2\2\2\u02df\u02e1\5\u0088"+
"E\2\u02e0\u02df\3\2\2\2\u02e0\u02e1\3\2\2\2\u02e1\u02e3\3\2\2\2\u02e2"+
"\u02da\3\2\2\2\u02e3\u02e4\3\2\2\2\u02e4\u02e2\3\2\2\2\u02e4\u02e5\3\2"+
"\2\2\u02e5\u0087\3\2\2\2\u02e6\u02e8\5r:\2\u02e7\u02e6\3\2\2\2\u02e8\u02e9"+
"\3\2\2\2\u02e9\u02e7\3\2\2\2\u02e9\u02ea\3\2\2\2\u02ea\u0089\3\2\2\2\u02eb"+
"\u02ee\5\u008cG\2\u02ec\u02ed\7[\2\2\u02ed\u02ef\7k\2\2\u02ee\u02ec\3"+
"\2\2\2\u02ee\u02ef\3\2\2\2\u02ef\u008b\3\2\2\2\u02f0\u02f5\5\u008eH\2"+
"\u02f1\u02f2\7[\2\2\u02f2\u02f4\5\u008eH\2\u02f3\u02f1\3\2\2\2\u02f4\u02f7"+
"\3\2\2\2\u02f5\u02f3\3\2\2\2\u02f5\u02f6\3\2\2\2\u02f6\u008d\3\2\2\2\u02f7"+
"\u02f5\3\2\2\2\u02f8\u02f9\5D#\2\u02f9\u02fa\5x=\2\u02fa\u0300\3\2\2\2"+
"\u02fb\u02fd\5F$\2\u02fc\u02fe\5\u0092J\2\u02fd\u02fc\3\2\2\2\u02fd\u02fe"+
"\3\2\2\2\u02fe\u0300\3\2\2\2\u02ff\u02f8\3\2\2\2\u02ff\u02fb\3\2\2\2\u0300"+
"\u008f\3\2\2\2\u0301\u0303\5`\61\2\u0302\u0304\5\u0092J\2\u0303\u0302"+
"\3\2\2\2\u0303\u0304\3\2\2\2\u0304\u0091\3\2\2\2\u0305\u0311\5\u0086D"+
"\2\u0306\u0308\5\u0086D\2\u0307\u0306\3\2\2\2\u0307\u0308\3\2\2\2\u0308"+
"\u0309\3\2\2\2\u0309\u030d\5\u0094K\2\u030a\u030c\5|?\2\u030b\u030a\3"+
"\2\2\2\u030c\u030f\3\2\2\2\u030d\u030b\3\2\2\2\u030d\u030e\3\2\2\2\u030e"+
"\u0311\3\2\2\2\u030f\u030d\3\2\2\2\u0310\u0305\3\2\2\2\u0310\u0307\3\2"+
"\2\2\u0311\u0093\3\2\2\2\u0312\u0313\bK\1\2\u0313\u0314\7>\2\2\u0314\u0315"+
"\5\u0092J\2\u0315\u0319\7?\2\2\u0316\u0318\5|?\2\u0317\u0316\3\2\2\2\u0318"+
"\u031b\3\2\2\2\u0319\u0317\3\2\2\2\u0319\u031a\3\2\2\2\u031a\u0341\3\2"+
"\2\2\u031b\u0319\3\2\2\2\u031c\u031e\7@\2\2\u031d\u031f\5\u0088E\2\u031e"+
"\u031d\3\2\2\2\u031e\u031f\3\2\2\2\u031f\u0321\3\2\2\2\u0320\u0322\5:"+
"\36\2\u0321\u0320\3\2\2\2\u0321\u0322\3\2\2\2\u0322\u0323\3\2\2\2\u0323"+
"\u0341\7A\2\2\u0324\u0325\7@\2\2\u0325\u0327\7+\2\2\u0326\u0328\5\u0088"+
"E\2\u0327\u0326\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u0329\3\2\2\2\u0329"+
"\u032a\5:\36\2\u032a\u032b\7A\2\2\u032b\u0341\3\2\2\2\u032c\u032d\7@\2"+
"\2\u032d\u032e\5\u0088E\2\u032e\u032f\7+\2\2\u032f\u0330\5:\36\2\u0330"+
"\u0331\7A\2\2\u0331\u0341\3\2\2\2\u0332\u0333\7@\2\2\u0333\u0334\7N\2"+
"\2\u0334\u0341\7A\2\2\u0335\u0337\7>\2\2\u0336\u0338\5\u008aF\2\u0337"+
"\u0336\3\2\2\2\u0337\u0338\3\2\2\2\u0338\u0339\3\2\2\2\u0339\u033d\7?"+
"\2\2\u033a\u033c\5|?\2\u033b\u033a\3\2\2\2\u033c\u033f\3\2\2\2\u033d\u033b"+
"\3\2\2\2\u033d\u033e\3\2\2\2\u033e\u0341\3\2\2\2\u033f\u033d\3\2\2\2\u0340"+
"\u0312\3\2\2\2\u0340\u031c\3\2\2\2\u0340\u0324\3\2\2\2\u0340\u032c\3\2"+
"\2\2\u0340\u0332\3\2\2\2\u0340\u0335\3\2\2\2\u0341\u036d\3\2\2\2\u0342"+
"\u0343\f\7\2\2\u0343\u0345\7@\2\2\u0344\u0346\5\u0088E\2\u0345\u0344\3"+
"\2\2\2\u0345\u0346\3\2\2\2\u0346\u0348\3\2\2\2\u0347\u0349\5:\36\2\u0348"+
"\u0347\3\2\2\2\u0348\u0349\3\2\2\2\u0349\u034a\3\2\2\2\u034a\u036c\7A"+
"\2\2\u034b\u034c\f\6\2\2\u034c\u034d\7@\2\2\u034d\u034f\7+\2\2\u034e\u0350"+
"\5\u0088E\2\u034f\u034e\3\2\2\2\u034f\u0350\3\2\2\2\u0350\u0351\3\2\2"+
"\2\u0351\u0352\5:\36\2\u0352\u0353\7A\2\2\u0353\u036c\3\2\2\2\u0354\u0355"+
"\f\5\2\2\u0355\u0356\7@\2\2\u0356\u0357\5\u0088E\2\u0357\u0358\7+\2\2"+
"\u0358\u0359\5:\36\2\u0359\u035a\7A\2\2\u035a\u036c\3\2\2\2\u035b\u035c"+
"\f\4\2\2\u035c\u035d\7@\2\2\u035d\u035e\7N\2\2\u035e\u036c\7A\2\2\u035f"+
"\u0360\f\3\2\2\u0360\u0362\7>\2\2\u0361\u0363\5\u008aF\2\u0362\u0361\3"+
"\2\2\2\u0362\u0363\3\2\2\2\u0363\u0364\3\2\2\2\u0364\u0368\7?\2\2\u0365"+
"\u0367\5|?\2\u0366\u0365\3\2\2\2\u0367\u036a\3\2\2\2\u0368\u0366\3\2\2"+
"\2\u0368\u0369\3\2\2\2\u0369\u036c\3\2\2\2\u036a\u0368\3\2\2\2\u036b\u0342"+
"\3\2\2\2\u036b\u034b\3\2\2\2\u036b\u0354\3\2\2\2\u036b\u035b\3\2\2\2\u036b"+
"\u035f\3\2\2\2\u036c\u036f\3\2\2\2\u036d\u036b\3\2\2\2\u036d\u036e\3\2"+
"\2\2\u036e\u0095\3\2\2\2\u036f\u036d\3\2\2\2\u0370\u0371\7l\2\2\u0371"+
"\u0097\3\2\2\2\u0372\u037b\5:\36\2\u0373\u0374\7B\2\2\u0374\u0376\5\u009a"+
"N\2\u0375\u0377\7[\2\2\u0376\u0375\3\2\2\2\u0376\u0377\3\2\2\2\u0377\u0378"+
"\3\2\2\2\u0378\u0379\7C\2\2\u0379\u037b\3\2\2\2\u037a\u0372\3\2\2\2\u037a"+
"\u0373\3\2\2\2\u037b\u0099\3\2\2\2\u037c\u037e\5\u009cO\2\u037d\u037c"+
"\3\2\2\2\u037d\u037e\3\2\2\2\u037e\u037f\3\2\2\2\u037f\u0387\5\u0098M"+
"\2\u0380\u0382\7[\2\2\u0381\u0383\5\u009cO\2\u0382\u0381\3\2\2\2\u0382"+
"\u0383\3\2\2\2\u0383\u0384\3\2\2\2\u0384\u0386\5\u0098M\2\u0385\u0380"+
"\3\2\2\2\u0386\u0389\3\2\2\2\u0387\u0385\3\2\2\2\u0387\u0388\3\2\2\2\u0388"+
"\u009b\3\2\2\2\u0389\u0387\3\2\2\2\u038a\u038b\5\u009eP\2\u038b\u038c"+
"\7\\\2\2\u038c\u009d\3\2\2\2\u038d\u038f\5\u00a0Q\2\u038e\u038d\3\2\2"+
"\2\u038f\u0390\3\2\2\2\u0390\u038e\3\2\2\2\u0390\u0391\3\2\2\2\u0391\u009f"+
"\3\2\2\2\u0392\u0393\7@\2\2\u0393\u0394\5@!\2\u0394\u0395\7A\2\2\u0395"+
"\u0399\3\2\2\2\u0396\u0397\7j\2\2\u0397\u0399\7l\2\2\u0398\u0392\3\2\2"+
"\2\u0398\u0396\3\2\2\2\u0399\u00a1\3\2\2\2\u039a\u03a3\5\u00a4S\2\u039b"+
"\u03a3\5\u00a6T\2\u039c\u03a3\5\u00acW\2\u039d\u03a3\5\u00aeX\2\u039e"+
"\u03a3\5\u00b0Y\2\u039f\u03a0\5\u00be`\2\u03a0\u03a1\7Z\2\2\u03a1\u03a3"+
"\3\2\2\2\u03a2\u039a\3\2\2\2\u03a2\u039b\3\2\2\2\u03a2\u039c\3\2\2\2\u03a2"+
"\u039d\3\2\2\2\u03a2\u039e\3\2\2\2\u03a2\u039f\3\2\2\2\u03a3\u00a3\3\2"+
"\2\2\u03a4\u03a5\7l\2\2\u03a5\u03a6\7Y\2\2\u03a6\u03b0\5\u00a2R\2\u03a7"+
"\u03a8\7\24\2\2\u03a8\u03a9\5@!\2\u03a9\u03aa\7Y\2\2\u03aa\u03ab\5\u00a2"+
"R\2\u03ab\u03b0\3\2\2\2\u03ac\u03ad\7\30\2\2\u03ad\u03ae\7Y\2\2\u03ae"+
"\u03b0\5\u00a2R\2\u03af\u03a4\3\2\2\2\u03af\u03a7\3\2\2\2\u03af\u03ac"+
"\3\2\2\2\u03b0\u00a5\3\2\2\2\u03b1\u03b3\7B\2\2\u03b2\u03b4\5\u00a8U\2"+
"\u03b3\u03b2\3\2\2\2\u03b3\u03b4\3\2\2\2\u03b4\u03b5\3\2\2\2\u03b5\u03b6"+
"\7C\2\2\u03b6\u00a7\3\2\2\2\u03b7\u03b9\5\u00aaV\2\u03b8\u03b7\3\2\2\2"+
"\u03b9\u03ba\3\2\2\2\u03ba\u03b8\3\2\2\2\u03ba\u03bb\3\2\2\2\u03bb\u00a9"+
"\3\2\2\2\u03bc\u03bf\5\u00a2R\2\u03bd\u03bf\5B\"\2\u03be\u03bc\3\2\2\2"+
"\u03be\u03bd\3\2\2\2\u03bf\u00ab\3\2\2\2\u03c0\u03c2\5> \2\u03c1\u03c0"+
"\3\2\2\2\u03c1\u03c2\3\2\2\2\u03c2\u03c3\3\2\2\2\u03c3\u03c4\7Z\2\2\u03c4"+
"\u00ad\3\2\2\2\u03c5\u03c6\7!\2\2\u03c6\u03c7\7>\2\2\u03c7\u03c8\5> \2"+
"\u03c8\u03c9\7?\2\2\u03c9\u03cc\5\u00a2R\2\u03ca\u03cb\7\33\2\2\u03cb"+
"\u03cd\5\u00a2R\2\u03cc\u03ca\3\2\2\2\u03cc\u03cd\3\2\2\2\u03cd\u03d5"+
"\3\2\2\2\u03ce\u03cf\7-\2\2\u03cf\u03d0\7>\2\2\u03d0\u03d1\5> \2\u03d1"+
"\u03d2\7?\2\2\u03d2\u03d3\5\u00a2R\2\u03d3\u03d5\3\2\2\2\u03d4\u03c5\3"+
"\2\2\2\u03d4\u03ce\3\2\2\2\u03d5\u00af\3\2\2\2\u03d6\u03d7\7\63\2\2\u03d7"+
"\u03d8\7>\2\2\u03d8\u03d9\5> \2\u03d9\u03da\7?\2\2\u03da\u03db\5\u00a2"+
"R\2\u03db\u03eb\3\2\2\2\u03dc\u03dd\7\31\2\2\u03dd\u03de\5\u00a2R\2\u03de"+
"\u03df\7\63\2\2\u03df\u03e0\7>\2\2\u03e0\u03e1\5> \2\u03e1\u03e2\7?\2"+
"\2\u03e2\u03e3\7Z\2\2\u03e3\u03eb\3\2\2\2\u03e4\u03e5\7\37\2\2\u03e5\u03e6"+
"\7>\2\2\u03e6\u03e7\5\u00b2Z\2\u03e7\u03e8\7?\2\2\u03e8\u03e9\5\u00a2"+
"R\2\u03e9\u03eb\3\2\2\2\u03ea\u03d6\3\2\2\2\u03ea\u03dc\3\2\2\2\u03ea"+
"\u03e4\3\2\2\2\u03eb\u00b1\3\2\2\2\u03ec\u03ed\5\u00b4[\2\u03ed\u03ee"+
"\7Z\2\2\u03ee\u03ef\5\u00b6\\\2\u03ef\u03f0\7Z\2\2\u03f0\u03f1\5\u00b8"+
"]\2\u03f1\u00b3\3\2\2\2\u03f2\u03f7\5\u00ba^\2\u03f3\u03f5\5> \2\u03f4"+
"\u03f3\3\2\2\2\u03f4\u03f5\3\2\2\2\u03f5\u03f7\3\2\2\2\u03f6\u03f2\3\2"+
"\2\2\u03f6\u03f4\3\2\2\2\u03f7\u00b5\3\2\2\2\u03f8\u03fa\5\u00bc_\2\u03f9"+
"\u03f8\3\2\2\2\u03f9\u03fa\3\2\2\2\u03fa\u00b7\3\2\2\2\u03fb\u03fd\5\u00bc"+
"_\2\u03fc\u03fb\3\2\2\2\u03fc\u03fd\3\2\2\2\u03fd\u00b9\3\2\2\2\u03fe"+
"\u0400\5D#\2\u03ff\u0401\5N(\2\u0400\u03ff\3\2\2\2\u0400\u0401\3\2\2\2"+
"\u0401\u00bb\3\2\2\2\u0402\u0407\5:\36\2\u0403\u0404\7[\2\2\u0404\u0406"+
"\5:\36\2\u0405\u0403\3\2\2\2\u0406\u0409\3\2\2\2\u0407\u0405\3\2\2\2\u0407"+
"\u0408\3\2\2\2\u0408\u00bd\3\2\2\2\u0409\u0407\3\2\2\2\u040a\u040b\7 "+
"\2\2\u040b\u0413\7l\2\2\u040c\u0413\7\27\2\2\u040d\u0413\7\23\2\2\u040e"+
"\u0410\7\'\2\2\u040f\u0411\5> \2\u0410\u040f\3\2\2\2\u0410\u0411\3\2\2"+
"\2\u0411\u0413\3\2\2\2\u0412\u040a\3\2\2\2\u0412\u040c\3\2\2\2\u0412\u040d"+
"\3\2\2\2\u0412\u040e\3\2\2\2\u0413\u00bf\3\2\2\2\u0414\u0416\5\u00c2b"+
"\2\u0415\u0414\3\2\2\2\u0415\u0416\3\2\2\2\u0416\u0417\3\2\2\2\u0417\u0418"+
"\7\2\2\3\u0418\u00c1\3\2\2\2\u0419\u041b\5\u00c4c\2\u041a\u0419\3\2\2"+
"\2\u041b\u041c\3\2\2\2\u041c\u041a\3\2\2\2\u041c\u041d\3\2\2\2\u041d\u00c3"+
"\3\2\2\2\u041e\u0422\5\u00c6d\2\u041f\u0422\5B\"\2\u0420\u0422\7Z\2\2"+
"\u0421\u041e\3\2\2\2\u0421\u041f\3\2\2\2\u0421\u0420\3\2\2\2\u0422\u00c5"+
"\3\2\2\2\u0423\u0424\5D#\2\u0424\u0425\5x=\2\u0425\u0426\5\u00a6T\2\u0426"+
"\u00c7\3\2\2\2\u0083\u00ce\u00d5\u00db\u00e1\u00ea\u00f2\u0105\u010a\u010c"+
"\u0112\u011f\u0126\u012e\u0135\u013d\u0145\u014d\u0155\u015d\u0165\u016d"+
"\u0175\u017d\u0186\u018d\u0196\u019d\u01a4\u01a9\u01ae\u01b2\u01b9\u01c1"+
"\u01c8\u01ce\u01e4\u01ec\u01f1\u01f9\u0202\u0209\u020d\u0214\u021b\u021d"+
"\u0221\u0228\u022d\u0231\u0235\u023a\u0240\u0247\u024d\u025e\u0264\u0269"+
"\u026f\u027b\u0280\u0283\u028a\u0299\u02a0\u02a3\u02a5\u02ad\u02b1\u02bb"+
"\u02bf\u02c3\u02c9\u02cc\u02d3\u02d5\u02da\u02dd\u02e0\u02e4\u02e9\u02ee"+
"\u02f5\u02fd\u02ff\u0303\u0307\u030d\u0310\u0319\u031e\u0321\u0327\u0337"+
"\u033d\u0340\u0345\u0348\u034f\u0362\u0368\u036b\u036d\u0376\u037a\u037d"+
"\u0382\u0387\u0390\u0398\u03a2\u03af\u03b3\u03ba\u03be\u03c1\u03cc\u03d4"+
"\u03ea\u03f4\u03f6\u03f9\u03fc\u0400\u0407\u0410\u0412\u0415\u041c\u0421";
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);
}
}
}