// Generated from src/antlr/C/Module.g4 by ANTLR 4.2.1-SNAPSHOT
package antlr.C;
import java.util.List;
import java.util.Stack;
import org.antlr.v4.runtime.FailedPredicateException;
import org.antlr.v4.runtime.NoViableAltException;
import org.antlr.v4.runtime.Parser;
import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.RecognitionException;
import org.antlr.v4.runtime.RuleContext;
import org.antlr.v4.runtime.RuleVersion;
import org.antlr.v4.runtime.TokenStream;
import org.antlr.v4.runtime.atn.ATN;
import org.antlr.v4.runtime.atn.ATNDeserializer;
import org.antlr.v4.runtime.atn.ParserATNSimulator;
import org.antlr.v4.runtime.tree.ParseTreeListener;
import org.antlr.v4.runtime.tree.TerminalNode;
public class ModuleParser extends Parser {
public static final int
T__55=1, T__54=2, T__53=3, T__52=4, T__51=5, T__50=6, T__49=7, T__48=8,
T__47=9, T__46=10, T__45=11, T__44=12, T__43=13, T__42=14, T__41=15, T__40=16,
T__39=17, T__38=18, T__37=19, T__36=20, T__35=21, T__34=22, T__33=23,
T__32=24, T__31=25, T__30=26, T__29=27, T__28=28, T__27=29, T__26=30,
T__25=31, T__24=32, T__23=33, T__22=34, T__21=35, T__20=36, T__19=37,
T__18=38, T__17=39, T__16=40, T__15=41, T__14=42, T__13=43, T__12=44,
T__11=45, T__10=46, T__9=47, T__8=48, T__7=49, T__6=50, T__5=51, T__4=52,
T__3=53, T__2=54, T__1=55, T__0=56, IF=57, ELSE=58, FOR=59, WHILE=60,
BREAK=61, CASE=62, CONTINUE=63, SWITCH=64, DO=65, GOTO=66, RETURN=67,
TYPEDEF=68, VOID=69, UNSIGNED=70, SIGNED=71, LONG=72, CV_QUALIFIER=73,
VIRTUAL=74, TRY=75, CATCH=76, THROW=77, USING=78, NAMESPACE=79, AUTO=80,
REGISTER=81, OPERATOR=82, TEMPLATE=83, NEW=84, CLASS_KEY=85, ALPHA_NUMERIC=86,
OPENING_CURLY=87, CLOSING_CURLY=88, PRE_IF=89, PRE_ELSE=90, PRE_ENDIF=91,
HEX_LITERAL=92, DECIMAL_LITERAL=93, OCTAL_LITERAL=94, FLOATING_POINT_LITERAL=95,
CHAR=96, STRING=97, COMMENT=98, WHITESPACE=99, CPPCOMMENT=100, OTHER=101;
public static final String[] tokenNames = {
"<INVALID>", "'&'", "'*'", "'['", "'<'", "'--'", "'!='", "'<='", "'<<'",
"'->'", "'%'", "'*='", "')'", "'explicit'", "'inline'", "'::'", "'='",
"'restrict'", "'|='", "'|'", "'!'", "'sizeof'", "']'", "'<<='", "'-='",
"'->*'", "'public'", "','", "'-'", "':'", "'('", "'&='", "'private'",
"'?'", "'>>='", "'...'", "'+='", "'^='", "'friend'", "'static'", "'++'",
"'>>'", "'delete'", "'^'", "'.'", "'+'", "'protected'", "';'", "'&&'",
"'||'", "'>'", "'%='", "'/='", "'/'", "'=='", "'~'", "'>='", "'if'", "'else'",
"'for'", "'while'", "'break'", "'case'", "'continue'", "'switch'", "'do'",
"'goto'", "'return'", "'typedef'", "'void'", "'unsigned'", "'signed'",
"'long'", "CV_QUALIFIER", "'virtual'", "'try'", "'catch'", "'throw'",
"'using'", "'namespace'", "'auto'", "'register'", "'operator'", "'template'",
"'new'", "CLASS_KEY", "ALPHA_NUMERIC", "'{'", "'}'", "PRE_IF", "PRE_ELSE",
"PRE_ENDIF", "HEX_LITERAL", "DECIMAL_LITERAL", "OCTAL_LITERAL", "FLOATING_POINT_LITERAL",
"CHAR", "STRING", "COMMENT", "WHITESPACE", "CPPCOMMENT", "OTHER"
};
public static final int
RULE_code = 0, RULE_using_directive = 1, RULE_expr = 2, RULE_assign_expr = 3,
RULE_conditional_expression = 4, RULE_or_expression = 5, RULE_and_expression = 6,
RULE_inclusive_or_expression = 7, RULE_exclusive_or_expression = 8, RULE_bit_and_expression = 9,
RULE_equality_expression = 10, RULE_relational_expression = 11, RULE_shift_expression = 12,
RULE_additive_expression = 13, RULE_multiplicative_expression = 14, RULE_cast_expression = 15,
RULE_cast_target = 16, RULE_unary_expression = 17, RULE_new_expression = 18,
RULE_unary_op_and_cast_expr = 19, RULE_sizeof_expression = 20, RULE_sizeof = 21,
RULE_sizeof_operand = 22, RULE_sizeof_operand2 = 23, RULE_inc_dec = 24,
RULE_postfix_expression = 25, RULE_function_argument_list = 26, RULE_function_argument = 27,
RULE_primary_expression = 28, RULE_unary_operator = 29, RULE_relational_operator = 30,
RULE_constant = 31, RULE_function_decl_specifiers = 32, RULE_ptr_operator = 33,
RULE_access_specifier = 34, RULE_operator = 35, RULE_assignment_operator = 36,
RULE_equality_operator = 37, RULE_template_decl_start = 38, RULE_template_param_list = 39,
RULE_no_brackets = 40, RULE_no_brackets_curlies_or_squares = 41, RULE_no_brackets_or_semicolon = 42,
RULE_no_angle_brackets_or_brackets = 43, RULE_no_curlies = 44, RULE_no_squares = 45,
RULE_no_squares_or_semicolon = 46, RULE_no_comma_or_semicolon = 47, RULE_assign_water = 48,
RULE_assign_water_l2 = 49, RULE_water = 50, RULE_function_def = 51, RULE_return_type = 52,
RULE_function_param_list = 53, RULE_parameter_decl_clause = 54, RULE_parameter_decl = 55,
RULE_parameter_id = 56, RULE_compound_statement = 57, RULE_ctor_list = 58,
RULE_ctor_initializer = 59, RULE_initializer_id = 60, RULE_ctor_expr = 61,
RULE_function_name = 62, RULE_exception_specification = 63, RULE_type_id_list = 64,
RULE_init_declarator = 65, RULE_declarator = 66, RULE_type_suffix = 67,
RULE_assign_expr_w_ = 68, RULE_assign_expr_w__l2 = 69, RULE_constant_expr_w_ = 70,
RULE_simple_decl = 71, RULE_var_decl = 72, RULE_init_declarator_list = 73,
RULE_initializer = 74, RULE_initializer_list = 75, RULE_class_def = 76,
RULE_class_name = 77, RULE_base_classes = 78, RULE_base_class = 79, RULE_type_name = 80,
RULE_base_type = 81, RULE_param_decl_specifiers = 82, RULE_parameter_name = 83,
RULE_param_type_list = 84, RULE_param_type = 85, RULE_param_type_id = 86,
RULE_identifier = 87, RULE_number = 88, RULE_ptrs = 89;
public static final String[] ruleNames = {
"code", "using_directive", "expr", "assign_expr", "conditional_expression",
"or_expression", "and_expression", "inclusive_or_expression", "exclusive_or_expression",
"bit_and_expression", "equality_expression", "relational_expression",
"shift_expression", "additive_expression", "multiplicative_expression",
"cast_expression", "cast_target", "unary_expression", "new_expression",
"unary_op_and_cast_expr", "sizeof_expression", "sizeof", "sizeof_operand",
"sizeof_operand2", "inc_dec", "postfix_expression", "function_argument_list",
"function_argument", "primary_expression", "unary_operator", "relational_operator",
"constant", "function_decl_specifiers", "ptr_operator", "access_specifier",
"operator", "assignment_operator", "equality_operator", "template_decl_start",
"template_param_list", "no_brackets", "no_brackets_curlies_or_squares",
"no_brackets_or_semicolon", "no_angle_brackets_or_brackets", "no_curlies",
"no_squares", "no_squares_or_semicolon", "no_comma_or_semicolon", "assign_water",
"assign_water_l2", "water", "function_def", "return_type", "function_param_list",
"parameter_decl_clause", "parameter_decl", "parameter_id", "compound_statement",
"ctor_list", "ctor_initializer", "initializer_id", "ctor_expr", "function_name",
"exception_specification", "type_id_list", "init_declarator", "declarator",
"type_suffix", "assign_expr_w_", "assign_expr_w__l2", "constant_expr_w_",
"simple_decl", "var_decl", "init_declarator_list", "initializer", "initializer_list",
"class_def", "class_name", "base_classes", "base_class", "type_name",
"base_type", "param_decl_specifiers", "parameter_name", "param_type_list",
"param_type", "param_type_id", "identifier", "number", "ptrs"
};
@Override
public String getGrammarFileName() { return "Module.g4"; }
@Override
public String[] getTokenNames() { return tokenNames; }
@Override
public String[] getRuleNames() { return ruleNames; }
@Override
public String getSerializedATN() { return _serializedATN; }
public boolean skipToEndOfObject()
{
Stack<Object> CurlyStack = new Stack<Object>();
Object o = new Object();
int t = _input.LA(1);
while(t != EOF && !(CurlyStack.empty() && t == CLOSING_CURLY)){
if(t == PRE_ELSE){
Stack<Object> ifdefStack = new Stack<Object>();
consume();
t = _input.LA(1);
while(t != EOF && !(ifdefStack.empty() && (t == PRE_ENDIF))){
if(t == PRE_IF)
ifdefStack.push(o);
else if(t == PRE_ENDIF)
ifdefStack.pop();
consume();
t = _input.LA(1);
}
}
if(t == OPENING_CURLY)
CurlyStack.push(o);
else if(t == CLOSING_CURLY)
CurlyStack.pop();
consume();
t = _input.LA(1);
}
if(t != EOF)
consume();
return true;
}
// this should go into FunctionGrammar but ANTLR fails
// to join the parser::members-section on inclusion
public boolean preProcSkipToEnd()
{
Stack<Object> CurlyStack = new Stack<Object>();
Object o = new Object();
int t = _input.LA(1);
while(t != EOF && !(CurlyStack.empty() && t == PRE_ENDIF)){
if(t == PRE_IF)
CurlyStack.push(o);
else if(t == PRE_ENDIF)
CurlyStack.pop();
consume();
t = _input.LA(1);
}
if(t != EOF)
consume();
return true;
}
public ModuleParser(TokenStream input) {
super(input);
_interp = new ParserATNSimulator(this,_ATN);
}
public static class CodeContext extends ParserRuleContext {
public List<? extends WaterContext> water() {
return getRuleContexts(WaterContext.class);
}
public Using_directiveContext using_directive(int i) {
return getRuleContext(Using_directiveContext.class,i);
}
public Simple_declContext simple_decl(int i) {
return getRuleContext(Simple_declContext.class,i);
}
public List<? extends Simple_declContext> simple_decl() {
return getRuleContexts(Simple_declContext.class);
}
public List<? extends Function_defContext> function_def() {
return getRuleContexts(Function_defContext.class);
}
public Function_defContext function_def(int i) {
return getRuleContext(Function_defContext.class,i);
}
public WaterContext water(int i) {
return getRuleContext(WaterContext.class,i);
}
public List<? extends Using_directiveContext> using_directive() {
return getRuleContexts(Using_directiveContext.class);
}
public CodeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_code; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterCode(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitCode(this);
}
}
@RuleVersion(0)
public final CodeContext code() throws RecognitionException {
CodeContext _localctx = new CodeContext(_ctx, getState());
enterRule(_localctx, 0, RULE_code);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(186);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 3) | (1L << 4) | (1L << 5) | (1L << 6) | (1L << 7) | (1L << 8) | (1L << 9) | (1L << 10) | (1L << 11) | (1L << 12) | (1L << 13) | (1L << 14) | (1L << 15) | (1L << 16) | (1L << 17) | (1L << 18) | (1L << 19) | (1L << 20) | (1L << 21) | (1L << 22) | (1L << 23) | (1L << 24) | (1L << 25) | (1L << 26) | (1L << 27) | (1L << 28) | (1L << 29) | (1L << 30) | (1L << 31) | (1L << 32) | (1L << 33) | (1L << 34) | (1L << 35) | (1L << 36) | (1L << 37) | (1L << 38) | (1L << 39) | (1L << 40) | (1L << 41) | (1L << 42) | (1L << 43) | (1L << 44) | (1L << 45) | (1L << 46) | (1L << 47) | (1L << 48) | (1L << 49) | (1L << 50) | (1L << 51) | (1L << 52) | (1L << 53) | (1L << 54) | (1L << 55) | (1L << 56) | (1L << IF) | (1L << ELSE) | (1L << FOR) | (1L << WHILE) | (1L << BREAK) | (1L << CASE) | (1L << CONTINUE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SWITCH - 64)) | (1L << (DO - 64)) | (1L << (GOTO - 64)) | (1L << (RETURN - 64)) | (1L << (TYPEDEF - 64)) | (1L << (VOID - 64)) | (1L << (UNSIGNED - 64)) | (1L << (SIGNED - 64)) | (1L << (LONG - 64)) | (1L << (CV_QUALIFIER - 64)) | (1L << (VIRTUAL - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (THROW - 64)) | (1L << (USING - 64)) | (1L << (NAMESPACE - 64)) | (1L << (AUTO - 64)) | (1L << (REGISTER - 64)) | (1L << (OPERATOR - 64)) | (1L << (TEMPLATE - 64)) | (1L << (NEW - 64)) | (1L << (CLASS_KEY - 64)) | (1L << (ALPHA_NUMERIC - 64)) | (1L << (OPENING_CURLY - 64)) | (1L << (CLOSING_CURLY - 64)) | (1L << (PRE_IF - 64)) | (1L << (PRE_ELSE - 64)) | (1L << (PRE_ENDIF - 64)) | (1L << (HEX_LITERAL - 64)) | (1L << (DECIMAL_LITERAL - 64)) | (1L << (OCTAL_LITERAL - 64)) | (1L << (FLOATING_POINT_LITERAL - 64)) | (1L << (CHAR - 64)) | (1L << (STRING - 64)) | (1L << (COMMENT - 64)) | (1L << (WHITESPACE - 64)) | (1L << (CPPCOMMENT - 64)) | (1L << (OTHER - 64)))) != 0)) {
{
setState(184);
switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) {
case 1:
{
setState(180); function_def();
}
break;
case 2:
{
setState(181); simple_decl();
}
break;
case 3:
{
setState(182); using_directive();
}
break;
case 4:
{
setState(183); water();
}
break;
}
}
setState(188);
_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 Using_directiveContext extends ParserRuleContext {
public TerminalNode USING() { return getToken(ModuleParser.USING, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode NAMESPACE() { return getToken(ModuleParser.NAMESPACE, 0); }
public Using_directiveContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_using_directive; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterUsing_directive(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitUsing_directive(this);
}
}
@RuleVersion(0)
public final Using_directiveContext using_directive() throws RecognitionException {
Using_directiveContext _localctx = new Using_directiveContext(_ctx, getState());
enterRule(_localctx, 2, RULE_using_directive);
try {
enterOuterAlt(_localctx, 1);
{
setState(189); match(USING);
setState(190); match(NAMESPACE);
setState(191); identifier();
setState(192); match(47);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ExprContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Assign_exprContext assign_expr() {
return getRuleContext(Assign_exprContext.class,0);
}
public ExprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitExpr(this);
}
}
@RuleVersion(0)
public final ExprContext expr() throws RecognitionException {
ExprContext _localctx = new ExprContext(_ctx, getState());
enterRule(_localctx, 4, RULE_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(194); assign_expr();
setState(197);
_la = _input.LA(1);
if (_la==27) {
{
setState(195); match(27);
setState(196); expr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Assign_exprContext extends ParserRuleContext {
public Assignment_operatorContext assignment_operator() {
return getRuleContext(Assignment_operatorContext.class,0);
}
public Conditional_expressionContext conditional_expression() {
return getRuleContext(Conditional_expressionContext.class,0);
}
public Assign_exprContext assign_expr() {
return getRuleContext(Assign_exprContext.class,0);
}
public Assign_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assign_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterAssign_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitAssign_expr(this);
}
}
@RuleVersion(0)
public final Assign_exprContext assign_expr() throws RecognitionException {
Assign_exprContext _localctx = new Assign_exprContext(_ctx, getState());
enterRule(_localctx, 6, RULE_assign_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(199); conditional_expression();
setState(203);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 11) | (1L << 16) | (1L << 18) | (1L << 23) | (1L << 24) | (1L << 31) | (1L << 34) | (1L << 36) | (1L << 37) | (1L << 51) | (1L << 52))) != 0)) {
{
setState(200); assignment_operator();
setState(201); assign_expr();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Conditional_expressionContext extends ParserRuleContext {
public Conditional_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_conditional_expression; }
public Conditional_expressionContext() { }
public void copyFrom(Conditional_expressionContext ctx) {
super.copyFrom(ctx);
}
}
public static class NormOrContext extends Conditional_expressionContext {
public Or_expressionContext or_expression() {
return getRuleContext(Or_expressionContext.class,0);
}
public NormOrContext(Conditional_expressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterNormOr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitNormOr(this);
}
}
public static class CndExprContext extends Conditional_expressionContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Conditional_expressionContext conditional_expression() {
return getRuleContext(Conditional_expressionContext.class,0);
}
public Or_expressionContext or_expression() {
return getRuleContext(Or_expressionContext.class,0);
}
public CndExprContext(Conditional_expressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterCndExpr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitCndExpr(this);
}
}
@RuleVersion(0)
public final Conditional_expressionContext conditional_expression() throws RecognitionException {
Conditional_expressionContext _localctx = new Conditional_expressionContext(_ctx, getState());
enterRule(_localctx, 8, RULE_conditional_expression);
try {
setState(212);
switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
case 1:
_localctx = new NormOrContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(205); or_expression();
}
break;
case 2:
_localctx = new CndExprContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(206); or_expression();
{
setState(207); match(33);
setState(208); expr();
setState(209); match(29);
setState(210); conditional_expression();
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Or_expressionContext extends ParserRuleContext {
public And_expressionContext and_expression() {
return getRuleContext(And_expressionContext.class,0);
}
public Or_expressionContext or_expression() {
return getRuleContext(Or_expressionContext.class,0);
}
public Or_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_or_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterOr_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitOr_expression(this);
}
}
@RuleVersion(0)
public final Or_expressionContext or_expression() throws RecognitionException {
Or_expressionContext _localctx = new Or_expressionContext(_ctx, getState());
enterRule(_localctx, 10, RULE_or_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(214); and_expression();
setState(217);
_la = _input.LA(1);
if (_la==49) {
{
setState(215); match(49);
setState(216); or_expression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class And_expressionContext extends ParserRuleContext {
public Inclusive_or_expressionContext inclusive_or_expression() {
return getRuleContext(Inclusive_or_expressionContext.class,0);
}
public And_expressionContext and_expression() {
return getRuleContext(And_expressionContext.class,0);
}
public And_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_and_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterAnd_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitAnd_expression(this);
}
}
@RuleVersion(0)
public final And_expressionContext and_expression() throws RecognitionException {
And_expressionContext _localctx = new And_expressionContext(_ctx, getState());
enterRule(_localctx, 12, RULE_and_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(219); inclusive_or_expression();
setState(222);
_la = _input.LA(1);
if (_la==48) {
{
setState(220); match(48);
setState(221); and_expression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Inclusive_or_expressionContext extends ParserRuleContext {
public Inclusive_or_expressionContext inclusive_or_expression() {
return getRuleContext(Inclusive_or_expressionContext.class,0);
}
public Exclusive_or_expressionContext exclusive_or_expression() {
return getRuleContext(Exclusive_or_expressionContext.class,0);
}
public Inclusive_or_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inclusive_or_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterInclusive_or_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitInclusive_or_expression(this);
}
}
@RuleVersion(0)
public final Inclusive_or_expressionContext inclusive_or_expression() throws RecognitionException {
Inclusive_or_expressionContext _localctx = new Inclusive_or_expressionContext(_ctx, getState());
enterRule(_localctx, 14, RULE_inclusive_or_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(224); exclusive_or_expression();
setState(227);
_la = _input.LA(1);
if (_la==19) {
{
setState(225); match(19);
setState(226); inclusive_or_expression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Exclusive_or_expressionContext extends ParserRuleContext {
public Bit_and_expressionContext bit_and_expression() {
return getRuleContext(Bit_and_expressionContext.class,0);
}
public Exclusive_or_expressionContext exclusive_or_expression() {
return getRuleContext(Exclusive_or_expressionContext.class,0);
}
public Exclusive_or_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exclusive_or_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterExclusive_or_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitExclusive_or_expression(this);
}
}
@RuleVersion(0)
public final Exclusive_or_expressionContext exclusive_or_expression() throws RecognitionException {
Exclusive_or_expressionContext _localctx = new Exclusive_or_expressionContext(_ctx, getState());
enterRule(_localctx, 16, RULE_exclusive_or_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(229); bit_and_expression();
setState(232);
_la = _input.LA(1);
if (_la==43) {
{
setState(230); match(43);
setState(231); exclusive_or_expression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Bit_and_expressionContext extends ParserRuleContext {
public Equality_expressionContext equality_expression() {
return getRuleContext(Equality_expressionContext.class,0);
}
public Bit_and_expressionContext bit_and_expression() {
return getRuleContext(Bit_and_expressionContext.class,0);
}
public Bit_and_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_bit_and_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterBit_and_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitBit_and_expression(this);
}
}
@RuleVersion(0)
public final Bit_and_expressionContext bit_and_expression() throws RecognitionException {
Bit_and_expressionContext _localctx = new Bit_and_expressionContext(_ctx, getState());
enterRule(_localctx, 18, RULE_bit_and_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(234); equality_expression();
setState(237);
_la = _input.LA(1);
if (_la==1) {
{
setState(235); match(1);
setState(236); bit_and_expression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Equality_expressionContext extends ParserRuleContext {
public Relational_expressionContext relational_expression() {
return getRuleContext(Relational_expressionContext.class,0);
}
public Equality_operatorContext equality_operator() {
return getRuleContext(Equality_operatorContext.class,0);
}
public Equality_expressionContext equality_expression() {
return getRuleContext(Equality_expressionContext.class,0);
}
public Equality_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_equality_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterEquality_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitEquality_expression(this);
}
}
@RuleVersion(0)
public final Equality_expressionContext equality_expression() throws RecognitionException {
Equality_expressionContext _localctx = new Equality_expressionContext(_ctx, getState());
enterRule(_localctx, 20, RULE_equality_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(239); relational_expression();
setState(243);
_la = _input.LA(1);
if (_la==6 || _la==54) {
{
setState(240); equality_operator();
setState(241); equality_expression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Relational_expressionContext extends ParserRuleContext {
public Relational_expressionContext relational_expression() {
return getRuleContext(Relational_expressionContext.class,0);
}
public Shift_expressionContext shift_expression() {
return getRuleContext(Shift_expressionContext.class,0);
}
public Relational_operatorContext relational_operator() {
return getRuleContext(Relational_operatorContext.class,0);
}
public Relational_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relational_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterRelational_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitRelational_expression(this);
}
}
@RuleVersion(0)
public final Relational_expressionContext relational_expression() throws RecognitionException {
Relational_expressionContext _localctx = new Relational_expressionContext(_ctx, getState());
enterRule(_localctx, 22, RULE_relational_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(245); shift_expression();
setState(249);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 4) | (1L << 7) | (1L << 50) | (1L << 56))) != 0)) {
{
setState(246); relational_operator();
setState(247); relational_expression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Shift_expressionContext extends ParserRuleContext {
public Shift_expressionContext shift_expression() {
return getRuleContext(Shift_expressionContext.class,0);
}
public Additive_expressionContext additive_expression() {
return getRuleContext(Additive_expressionContext.class,0);
}
public Shift_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_shift_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterShift_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitShift_expression(this);
}
}
@RuleVersion(0)
public final Shift_expressionContext shift_expression() throws RecognitionException {
Shift_expressionContext _localctx = new Shift_expressionContext(_ctx, getState());
enterRule(_localctx, 24, RULE_shift_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(251); additive_expression();
setState(254);
_la = _input.LA(1);
if (_la==8 || _la==41) {
{
setState(252);
_la = _input.LA(1);
if ( !(_la==8 || _la==41) ) {
_errHandler.recoverInline(this);
}
consume();
setState(253); shift_expression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Additive_expressionContext extends ParserRuleContext {
public Additive_expressionContext additive_expression() {
return getRuleContext(Additive_expressionContext.class,0);
}
public Multiplicative_expressionContext multiplicative_expression() {
return getRuleContext(Multiplicative_expressionContext.class,0);
}
public Additive_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_additive_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterAdditive_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitAdditive_expression(this);
}
}
@RuleVersion(0)
public final Additive_expressionContext additive_expression() throws RecognitionException {
Additive_expressionContext _localctx = new Additive_expressionContext(_ctx, getState());
enterRule(_localctx, 26, RULE_additive_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(256); multiplicative_expression();
setState(259);
_la = _input.LA(1);
if (_la==28 || _la==45) {
{
setState(257);
_la = _input.LA(1);
if ( !(_la==28 || _la==45) ) {
_errHandler.recoverInline(this);
}
consume();
setState(258); additive_expression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Multiplicative_expressionContext extends ParserRuleContext {
public Cast_expressionContext cast_expression() {
return getRuleContext(Cast_expressionContext.class,0);
}
public Multiplicative_expressionContext multiplicative_expression() {
return getRuleContext(Multiplicative_expressionContext.class,0);
}
public Multiplicative_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_multiplicative_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterMultiplicative_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitMultiplicative_expression(this);
}
}
@RuleVersion(0)
public final Multiplicative_expressionContext multiplicative_expression() throws RecognitionException {
Multiplicative_expressionContext _localctx = new Multiplicative_expressionContext(_ctx, getState());
enterRule(_localctx, 28, RULE_multiplicative_expression);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(261); cast_expression();
setState(264);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 2) | (1L << 10) | (1L << 53))) != 0)) {
{
setState(262);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 2) | (1L << 10) | (1L << 53))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
setState(263); multiplicative_expression();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Cast_expressionContext extends ParserRuleContext {
public Cast_expressionContext cast_expression() {
return getRuleContext(Cast_expressionContext.class,0);
}
public Cast_targetContext cast_target() {
return getRuleContext(Cast_targetContext.class,0);
}
public Unary_expressionContext unary_expression() {
return getRuleContext(Unary_expressionContext.class,0);
}
public Cast_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cast_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterCast_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitCast_expression(this);
}
}
@RuleVersion(0)
public final Cast_expressionContext cast_expression() throws RecognitionException {
Cast_expressionContext _localctx = new Cast_expressionContext(_ctx, getState());
enterRule(_localctx, 30, RULE_cast_expression);
try {
setState(272);
switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
{
setState(266); match(30);
setState(267); cast_target();
setState(268); match(12);
setState(269); cast_expression();
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(271); unary_expression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Cast_targetContext extends ParserRuleContext {
public Type_nameContext type_name() {
return getRuleContext(Type_nameContext.class,0);
}
public List<? extends Ptr_operatorContext> ptr_operator() {
return getRuleContexts(Ptr_operatorContext.class);
}
public Ptr_operatorContext ptr_operator(int i) {
return getRuleContext(Ptr_operatorContext.class,i);
}
public Cast_targetContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_cast_target; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterCast_target(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitCast_target(this);
}
}
@RuleVersion(0)
public final Cast_targetContext cast_target() throws RecognitionException {
Cast_targetContext _localctx = new Cast_targetContext(_ctx, getState());
enterRule(_localctx, 32, RULE_cast_target);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(274); type_name();
setState(278);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==1 || _la==2) {
{
{
setState(275); ptr_operator();
}
}
setState(280);
_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 Unary_expressionContext extends ParserRuleContext {
public Cast_expressionContext cast_expression() {
return getRuleContext(Cast_expressionContext.class,0);
}
public Sizeof_expressionContext sizeof_expression() {
return getRuleContext(Sizeof_expressionContext.class,0);
}
public New_expressionContext new_expression() {
return getRuleContext(New_expressionContext.class,0);
}
public Inc_decContext inc_dec() {
return getRuleContext(Inc_decContext.class,0);
}
public Unary_op_and_cast_exprContext unary_op_and_cast_expr() {
return getRuleContext(Unary_op_and_cast_exprContext.class,0);
}
public Postfix_expressionContext postfix_expression() {
return getRuleContext(Postfix_expressionContext.class,0);
}
public Unary_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unary_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterUnary_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitUnary_expression(this);
}
}
@RuleVersion(0)
public final Unary_expressionContext unary_expression() throws RecognitionException {
Unary_expressionContext _localctx = new Unary_expressionContext(_ctx, getState());
enterRule(_localctx, 34, RULE_unary_expression);
try {
setState(288);
switch (_input.LA(1)) {
case 5:
case 40:
enterOuterAlt(_localctx, 1);
{
setState(281); inc_dec();
setState(282); cast_expression();
}
break;
case 1:
case 2:
case 20:
case 28:
case 45:
case 55:
enterOuterAlt(_localctx, 2);
{
setState(284); unary_op_and_cast_expr();
}
break;
case 21:
enterOuterAlt(_localctx, 3);
{
setState(285); sizeof_expression();
}
break;
case 15:
case NEW:
enterOuterAlt(_localctx, 4);
{
setState(286); new_expression();
}
break;
case 26:
case 30:
case 32:
case 46:
case ALPHA_NUMERIC:
case HEX_LITERAL:
case DECIMAL_LITERAL:
case OCTAL_LITERAL:
case FLOATING_POINT_LITERAL:
case CHAR:
case STRING:
enterOuterAlt(_localctx, 5);
{
setState(287); postfix_expression(0);
}
break;
default:
throw new NoViableAltException(this);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class New_expressionContext extends ParserRuleContext {
public TerminalNode NEW() { return getToken(ModuleParser.NEW, 0); }
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Type_nameContext type_name() {
return getRuleContext(Type_nameContext.class,0);
}
public Conditional_expressionContext conditional_expression() {
return getRuleContext(Conditional_expressionContext.class,0);
}
public New_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_new_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterNew_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitNew_expression(this);
}
}
@RuleVersion(0)
public final New_expressionContext new_expression() throws RecognitionException {
New_expressionContext _localctx = new New_expressionContext(_ctx, getState());
enterRule(_localctx, 36, RULE_new_expression);
int _la;
try {
setState(312);
switch ( getInterpreter().adaptivePredict(_input,22,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(291);
_la = _input.LA(1);
if (_la==15) {
{
setState(290); match(15);
}
}
setState(293); match(NEW);
setState(294); type_name();
setState(295); match(3);
setState(297);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 5) | (1L << 15) | (1L << 20) | (1L << 21) | (1L << 26) | (1L << 28) | (1L << 30) | (1L << 32) | (1L << 40) | (1L << 45) | (1L << 46) | (1L << 55))) != 0) || ((((_la - 84)) & ~0x3f) == 0 && ((1L << (_la - 84)) & ((1L << (NEW - 84)) | (1L << (ALPHA_NUMERIC - 84)) | (1L << (HEX_LITERAL - 84)) | (1L << (DECIMAL_LITERAL - 84)) | (1L << (OCTAL_LITERAL - 84)) | (1L << (FLOATING_POINT_LITERAL - 84)) | (1L << (CHAR - 84)) | (1L << (STRING - 84)))) != 0)) {
{
setState(296); conditional_expression();
}
}
setState(299); match(22);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(302);
_la = _input.LA(1);
if (_la==15) {
{
setState(301); match(15);
}
}
setState(304); match(NEW);
setState(305); type_name();
setState(306); match(30);
setState(308);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 5) | (1L << 15) | (1L << 20) | (1L << 21) | (1L << 26) | (1L << 28) | (1L << 30) | (1L << 32) | (1L << 40) | (1L << 45) | (1L << 46) | (1L << 55))) != 0) || ((((_la - 84)) & ~0x3f) == 0 && ((1L << (_la - 84)) & ((1L << (NEW - 84)) | (1L << (ALPHA_NUMERIC - 84)) | (1L << (HEX_LITERAL - 84)) | (1L << (DECIMAL_LITERAL - 84)) | (1L << (OCTAL_LITERAL - 84)) | (1L << (FLOATING_POINT_LITERAL - 84)) | (1L << (CHAR - 84)) | (1L << (STRING - 84)))) != 0)) {
{
setState(307); expr();
}
}
setState(310); match(12);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Unary_op_and_cast_exprContext extends ParserRuleContext {
public Cast_expressionContext cast_expression() {
return getRuleContext(Cast_expressionContext.class,0);
}
public Unary_operatorContext unary_operator() {
return getRuleContext(Unary_operatorContext.class,0);
}
public Unary_op_and_cast_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unary_op_and_cast_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterUnary_op_and_cast_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitUnary_op_and_cast_expr(this);
}
}
@RuleVersion(0)
public final Unary_op_and_cast_exprContext unary_op_and_cast_expr() throws RecognitionException {
Unary_op_and_cast_exprContext _localctx = new Unary_op_and_cast_exprContext(_ctx, getState());
enterRule(_localctx, 38, RULE_unary_op_and_cast_expr);
try {
enterOuterAlt(_localctx, 1);
{
setState(314); unary_operator();
setState(315); cast_expression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Sizeof_expressionContext extends ParserRuleContext {
public Sizeof_operand2Context sizeof_operand2() {
return getRuleContext(Sizeof_operand2Context.class,0);
}
public SizeofContext sizeof() {
return getRuleContext(SizeofContext.class,0);
}
public Sizeof_operandContext sizeof_operand() {
return getRuleContext(Sizeof_operandContext.class,0);
}
public Sizeof_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sizeof_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterSizeof_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitSizeof_expression(this);
}
}
@RuleVersion(0)
public final Sizeof_expressionContext sizeof_expression() throws RecognitionException {
Sizeof_expressionContext _localctx = new Sizeof_expressionContext(_ctx, getState());
enterRule(_localctx, 40, RULE_sizeof_expression);
try {
setState(325);
switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(317); sizeof();
setState(318); match(30);
setState(319); sizeof_operand();
setState(320); match(12);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(322); sizeof();
setState(323); sizeof_operand2();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class SizeofContext extends ParserRuleContext {
public SizeofContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sizeof; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterSizeof(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitSizeof(this);
}
}
@RuleVersion(0)
public final SizeofContext sizeof() throws RecognitionException {
SizeofContext _localctx = new SizeofContext(_ctx, getState());
enterRule(_localctx, 42, RULE_sizeof);
try {
enterOuterAlt(_localctx, 1);
{
setState(327); match(21);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Sizeof_operandContext extends ParserRuleContext {
public Type_nameContext type_name() {
return getRuleContext(Type_nameContext.class,0);
}
public List<? extends Ptr_operatorContext> ptr_operator() {
return getRuleContexts(Ptr_operatorContext.class);
}
public Ptr_operatorContext ptr_operator(int i) {
return getRuleContext(Ptr_operatorContext.class,i);
}
public Sizeof_operandContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sizeof_operand; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterSizeof_operand(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitSizeof_operand(this);
}
}
@RuleVersion(0)
public final Sizeof_operandContext sizeof_operand() throws RecognitionException {
Sizeof_operandContext _localctx = new Sizeof_operandContext(_ctx, getState());
enterRule(_localctx, 44, RULE_sizeof_operand);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(329); type_name();
setState(333);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==1 || _la==2) {
{
{
setState(330); ptr_operator();
}
}
setState(335);
_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 Sizeof_operand2Context extends ParserRuleContext {
public Unary_expressionContext unary_expression() {
return getRuleContext(Unary_expressionContext.class,0);
}
public Sizeof_operand2Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_sizeof_operand2; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterSizeof_operand2(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitSizeof_operand2(this);
}
}
@RuleVersion(0)
public final Sizeof_operand2Context sizeof_operand2() throws RecognitionException {
Sizeof_operand2Context _localctx = new Sizeof_operand2Context(_ctx, getState());
enterRule(_localctx, 46, RULE_sizeof_operand2);
try {
enterOuterAlt(_localctx, 1);
{
setState(336); unary_expression();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Inc_decContext extends ParserRuleContext {
public Inc_decContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_inc_dec; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterInc_dec(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitInc_dec(this);
}
}
@RuleVersion(0)
public final Inc_decContext inc_dec() throws RecognitionException {
Inc_decContext _localctx = new Inc_decContext(_ctx, getState());
enterRule(_localctx, 48, RULE_inc_dec);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(338);
_la = _input.LA(1);
if ( !(_la==5 || _la==40) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Postfix_expressionContext extends ParserRuleContext {
public Postfix_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_postfix_expression; }
public Postfix_expressionContext() { }
public void copyFrom(Postfix_expressionContext ctx) {
super.copyFrom(ctx);
}
}
public static class PrimaryOnlyContext extends Postfix_expressionContext {
public Primary_expressionContext primary_expression() {
return getRuleContext(Primary_expressionContext.class,0);
}
public PrimaryOnlyContext(Postfix_expressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterPrimaryOnly(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitPrimaryOnly(this);
}
}
public static class PtrMemberAccessContext extends Postfix_expressionContext {
public TerminalNode TEMPLATE() { return getToken(ModuleParser.TEMPLATE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public Postfix_expressionContext postfix_expression() {
return getRuleContext(Postfix_expressionContext.class,0);
}
public PtrMemberAccessContext(Postfix_expressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterPtrMemberAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitPtrMemberAccess(this);
}
}
public static class ArrayIndexingContext extends Postfix_expressionContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Postfix_expressionContext postfix_expression() {
return getRuleContext(Postfix_expressionContext.class,0);
}
public ArrayIndexingContext(Postfix_expressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterArrayIndexing(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitArrayIndexing(this);
}
}
public static class IncDecOpContext extends Postfix_expressionContext {
public Inc_decContext inc_dec() {
return getRuleContext(Inc_decContext.class,0);
}
public Postfix_expressionContext postfix_expression() {
return getRuleContext(Postfix_expressionContext.class,0);
}
public IncDecOpContext(Postfix_expressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterIncDecOp(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitIncDecOp(this);
}
}
public static class MemberAccessContext extends Postfix_expressionContext {
public TerminalNode TEMPLATE() { return getToken(ModuleParser.TEMPLATE, 0); }
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public Postfix_expressionContext postfix_expression() {
return getRuleContext(Postfix_expressionContext.class,0);
}
public MemberAccessContext(Postfix_expressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterMemberAccess(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitMemberAccess(this);
}
}
public static class FuncCallContext extends Postfix_expressionContext {
public Function_argument_listContext function_argument_list() {
return getRuleContext(Function_argument_listContext.class,0);
}
public Postfix_expressionContext postfix_expression() {
return getRuleContext(Postfix_expressionContext.class,0);
}
public FuncCallContext(Postfix_expressionContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterFuncCall(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitFuncCall(this);
}
}
@RuleVersion(0)
public final Postfix_expressionContext postfix_expression() throws RecognitionException {
return postfix_expression(0);
}
private Postfix_expressionContext postfix_expression(int _p) throws RecognitionException {
ParserRuleContext _parentctx = _ctx;
int _parentState = getState();
Postfix_expressionContext _localctx = new Postfix_expressionContext(_ctx, _parentState);
Postfix_expressionContext _prevctx = _localctx;
int _startState = 50;
enterRecursionRule(_localctx, 50, RULE_postfix_expression, _p);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
{
_localctx = new PrimaryOnlyContext(_localctx);
_ctx = _localctx;
_prevctx = _localctx;
setState(341); primary_expression();
}
_ctx.stop = _input.LT(-1);
setState(369);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
if ( _parseListeners!=null ) triggerExitRuleEvent();
_prevctx = _localctx;
{
setState(367);
switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
case 1:
{
_localctx = new ArrayIndexingContext(new Postfix_expressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_postfix_expression);
setState(343);
if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
setState(344); match(3);
setState(345); expr();
setState(346); match(22);
}
break;
case 2:
{
_localctx = new FuncCallContext(new Postfix_expressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_postfix_expression);
setState(348);
if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
setState(349); match(30);
setState(350); function_argument_list();
setState(351); match(12);
}
break;
case 3:
{
_localctx = new MemberAccessContext(new Postfix_expressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_postfix_expression);
setState(353);
if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)");
setState(354); match(44);
setState(356);
_la = _input.LA(1);
if (_la==TEMPLATE) {
{
setState(355); match(TEMPLATE);
}
}
{
setState(358); identifier();
}
}
break;
case 4:
{
_localctx = new PtrMemberAccessContext(new Postfix_expressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_postfix_expression);
setState(359);
if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
setState(360); match(9);
setState(362);
_la = _input.LA(1);
if (_la==TEMPLATE) {
{
setState(361); match(TEMPLATE);
}
}
{
setState(364); identifier();
}
}
break;
case 5:
{
_localctx = new IncDecOpContext(new Postfix_expressionContext(_parentctx, _parentState));
pushNewRecursionContext(_localctx, _startState, RULE_postfix_expression);
setState(365);
if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
setState(366); inc_dec();
}
break;
}
}
}
setState(371);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,28,_ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
unrollRecursionContexts(_parentctx);
}
return _localctx;
}
public static class Function_argument_listContext extends ParserRuleContext {
public Function_argumentContext function_argument(int i) {
return getRuleContext(Function_argumentContext.class,i);
}
public List<? extends Function_argumentContext> function_argument() {
return getRuleContexts(Function_argumentContext.class);
}
public Function_argument_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function_argument_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterFunction_argument_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitFunction_argument_list(this);
}
}
@RuleVersion(0)
public final Function_argument_listContext function_argument_list() throws RecognitionException {
Function_argument_listContext _localctx = new Function_argument_listContext(_ctx, getState());
enterRule(_localctx, 52, RULE_function_argument_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(380);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 5) | (1L << 15) | (1L << 20) | (1L << 21) | (1L << 26) | (1L << 28) | (1L << 30) | (1L << 32) | (1L << 40) | (1L << 45) | (1L << 46) | (1L << 55))) != 0) || ((((_la - 84)) & ~0x3f) == 0 && ((1L << (_la - 84)) & ((1L << (NEW - 84)) | (1L << (ALPHA_NUMERIC - 84)) | (1L << (HEX_LITERAL - 84)) | (1L << (DECIMAL_LITERAL - 84)) | (1L << (OCTAL_LITERAL - 84)) | (1L << (FLOATING_POINT_LITERAL - 84)) | (1L << (CHAR - 84)) | (1L << (STRING - 84)))) != 0)) {
{
setState(372); function_argument();
setState(377);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==27) {
{
{
setState(373); match(27);
setState(374); function_argument();
}
}
setState(379);
_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 Function_argumentContext extends ParserRuleContext {
public Assign_exprContext assign_expr() {
return getRuleContext(Assign_exprContext.class,0);
}
public Function_argumentContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function_argument; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterFunction_argument(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitFunction_argument(this);
}
}
@RuleVersion(0)
public final Function_argumentContext function_argument() throws RecognitionException {
Function_argumentContext _localctx = new Function_argumentContext(_ctx, getState());
enterRule(_localctx, 54, RULE_function_argument);
try {
enterOuterAlt(_localctx, 1);
{
setState(382); assign_expr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Primary_expressionContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public ConstantContext constant() {
return getRuleContext(ConstantContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public Primary_expressionContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_primary_expression; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterPrimary_expression(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitPrimary_expression(this);
}
}
@RuleVersion(0)
public final Primary_expressionContext primary_expression() throws RecognitionException {
Primary_expressionContext _localctx = new Primary_expressionContext(_ctx, getState());
enterRule(_localctx, 56, RULE_primary_expression);
try {
setState(390);
switch (_input.LA(1)) {
case 26:
case 32:
case 46:
case ALPHA_NUMERIC:
enterOuterAlt(_localctx, 1);
{
setState(384); identifier();
}
break;
case HEX_LITERAL:
case DECIMAL_LITERAL:
case OCTAL_LITERAL:
case FLOATING_POINT_LITERAL:
case CHAR:
case STRING:
enterOuterAlt(_localctx, 2);
{
setState(385); constant();
}
break;
case 30:
enterOuterAlt(_localctx, 3);
{
setState(386); match(30);
setState(387); expr();
setState(388); match(12);
}
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 Unary_operatorContext extends ParserRuleContext {
public Unary_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_unary_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterUnary_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitUnary_operator(this);
}
}
@RuleVersion(0)
public final Unary_operatorContext unary_operator() throws RecognitionException {
Unary_operatorContext _localctx = new Unary_operatorContext(_ctx, getState());
enterRule(_localctx, 58, RULE_unary_operator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(392);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 20) | (1L << 28) | (1L << 45) | (1L << 55))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Relational_operatorContext extends ParserRuleContext {
public Relational_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_relational_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterRelational_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitRelational_operator(this);
}
}
@RuleVersion(0)
public final Relational_operatorContext relational_operator() throws RecognitionException {
Relational_operatorContext _localctx = new Relational_operatorContext(_ctx, getState());
enterRule(_localctx, 60, RULE_relational_operator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(394);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 4) | (1L << 7) | (1L << 50) | (1L << 56))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class ConstantContext extends ParserRuleContext {
public TerminalNode OCTAL_LITERAL() { return getToken(ModuleParser.OCTAL_LITERAL, 0); }
public TerminalNode DECIMAL_LITERAL() { return getToken(ModuleParser.DECIMAL_LITERAL, 0); }
public TerminalNode FLOATING_POINT_LITERAL() { return getToken(ModuleParser.FLOATING_POINT_LITERAL, 0); }
public TerminalNode CHAR() { return getToken(ModuleParser.CHAR, 0); }
public TerminalNode STRING() { return getToken(ModuleParser.STRING, 0); }
public TerminalNode HEX_LITERAL() { return getToken(ModuleParser.HEX_LITERAL, 0); }
public ConstantContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constant; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterConstant(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitConstant(this);
}
}
@RuleVersion(0)
public final ConstantContext constant() throws RecognitionException {
ConstantContext _localctx = new ConstantContext(_ctx, getState());
enterRule(_localctx, 62, RULE_constant);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(396);
_la = _input.LA(1);
if ( !(((((_la - 92)) & ~0x3f) == 0 && ((1L << (_la - 92)) & ((1L << (HEX_LITERAL - 92)) | (1L << (DECIMAL_LITERAL - 92)) | (1L << (OCTAL_LITERAL - 92)) | (1L << (FLOATING_POINT_LITERAL - 92)) | (1L << (CHAR - 92)) | (1L << (STRING - 92)))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Function_decl_specifiersContext extends ParserRuleContext {
public Function_decl_specifiersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function_decl_specifiers; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterFunction_decl_specifiers(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitFunction_decl_specifiers(this);
}
}
@RuleVersion(0)
public final Function_decl_specifiersContext function_decl_specifiers() throws RecognitionException {
Function_decl_specifiersContext _localctx = new Function_decl_specifiersContext(_ctx, getState());
enterRule(_localctx, 64, RULE_function_decl_specifiers);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(398);
_la = _input.LA(1);
if ( !(((((_la - 13)) & ~0x3f) == 0 && ((1L << (_la - 13)) & ((1L << (13 - 13)) | (1L << (14 - 13)) | (1L << (38 - 13)) | (1L << (39 - 13)) | (1L << (VIRTUAL - 13)))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Ptr_operatorContext extends ParserRuleContext {
public Ptr_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ptr_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterPtr_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitPtr_operator(this);
}
}
@RuleVersion(0)
public final Ptr_operatorContext ptr_operator() throws RecognitionException {
Ptr_operatorContext _localctx = new Ptr_operatorContext(_ctx, getState());
enterRule(_localctx, 66, RULE_ptr_operator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(400);
_la = _input.LA(1);
if ( !(_la==1 || _la==2) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Access_specifierContext extends ParserRuleContext {
public Access_specifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_access_specifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterAccess_specifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitAccess_specifier(this);
}
}
@RuleVersion(0)
public final Access_specifierContext access_specifier() throws RecognitionException {
Access_specifierContext _localctx = new Access_specifierContext(_ctx, getState());
enterRule(_localctx, 68, RULE_access_specifier);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(402);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 26) | (1L << 32) | (1L << 46))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class OperatorContext extends ParserRuleContext {
public OperatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterOperator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitOperator(this);
}
}
@RuleVersion(0)
public final OperatorContext operator() throws RecognitionException {
OperatorContext _localctx = new OperatorContext(_ctx, getState());
enterRule(_localctx, 70, RULE_operator);
int _la;
try {
setState(449);
switch (_input.LA(1)) {
case 42:
case NEW:
enterOuterAlt(_localctx, 1);
{
{
setState(404);
_la = _input.LA(1);
if ( !(_la==42 || _la==NEW) ) {
_errHandler.recoverInline(this);
}
consume();
setState(407);
_la = _input.LA(1);
if (_la==3) {
{
setState(405); match(3);
setState(406); match(22);
}
}
}
}
break;
case 45:
enterOuterAlt(_localctx, 2);
{
setState(409); match(45);
}
break;
case 28:
enterOuterAlt(_localctx, 3);
{
setState(410); match(28);
}
break;
case 2:
enterOuterAlt(_localctx, 4);
{
setState(411); match(2);
}
break;
case 53:
enterOuterAlt(_localctx, 5);
{
setState(412); match(53);
}
break;
case 10:
enterOuterAlt(_localctx, 6);
{
setState(413); match(10);
}
break;
case 43:
enterOuterAlt(_localctx, 7);
{
setState(414); match(43);
}
break;
case 1:
enterOuterAlt(_localctx, 8);
{
setState(415); match(1);
}
break;
case 19:
enterOuterAlt(_localctx, 9);
{
setState(416); match(19);
}
break;
case 55:
enterOuterAlt(_localctx, 10);
{
setState(417); match(55);
}
break;
case 20:
enterOuterAlt(_localctx, 11);
{
setState(418); match(20);
}
break;
case 16:
enterOuterAlt(_localctx, 12);
{
setState(419); match(16);
}
break;
case 4:
enterOuterAlt(_localctx, 13);
{
setState(420); match(4);
}
break;
case 50:
enterOuterAlt(_localctx, 14);
{
setState(421); match(50);
}
break;
case 36:
enterOuterAlt(_localctx, 15);
{
setState(422); match(36);
}
break;
case 24:
enterOuterAlt(_localctx, 16);
{
setState(423); match(24);
}
break;
case 11:
enterOuterAlt(_localctx, 17);
{
setState(424); match(11);
}
break;
case 52:
enterOuterAlt(_localctx, 18);
{
setState(425); match(52);
}
break;
case 51:
enterOuterAlt(_localctx, 19);
{
setState(426); match(51);
}
break;
case 37:
enterOuterAlt(_localctx, 20);
{
setState(427); match(37);
}
break;
case 31:
enterOuterAlt(_localctx, 21);
{
setState(428); match(31);
}
break;
case 18:
enterOuterAlt(_localctx, 22);
{
setState(429); match(18);
}
break;
case 41:
enterOuterAlt(_localctx, 23);
{
setState(430); match(41);
}
break;
case 8:
enterOuterAlt(_localctx, 24);
{
setState(431); match(8);
}
break;
case 34:
enterOuterAlt(_localctx, 25);
{
setState(432); match(34);
}
break;
case 23:
enterOuterAlt(_localctx, 26);
{
setState(433); match(23);
}
break;
case 54:
enterOuterAlt(_localctx, 27);
{
setState(434); match(54);
}
break;
case 6:
enterOuterAlt(_localctx, 28);
{
setState(435); match(6);
}
break;
case 7:
enterOuterAlt(_localctx, 29);
{
setState(436); match(7);
}
break;
case 56:
enterOuterAlt(_localctx, 30);
{
setState(437); match(56);
}
break;
case 48:
enterOuterAlt(_localctx, 31);
{
setState(438); match(48);
}
break;
case 49:
enterOuterAlt(_localctx, 32);
{
setState(439); match(49);
}
break;
case 40:
enterOuterAlt(_localctx, 33);
{
setState(440); match(40);
}
break;
case 5:
enterOuterAlt(_localctx, 34);
{
setState(441); match(5);
}
break;
case 27:
enterOuterAlt(_localctx, 35);
{
setState(442); match(27);
}
break;
case 25:
enterOuterAlt(_localctx, 36);
{
setState(443); match(25);
}
break;
case 9:
enterOuterAlt(_localctx, 37);
{
setState(444); match(9);
}
break;
case 30:
enterOuterAlt(_localctx, 38);
{
setState(445); match(30);
setState(446); match(12);
}
break;
case 3:
enterOuterAlt(_localctx, 39);
{
setState(447); match(3);
setState(448); match(22);
}
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 Assignment_operatorContext extends ParserRuleContext {
public Assignment_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assignment_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterAssignment_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitAssignment_operator(this);
}
}
@RuleVersion(0)
public final Assignment_operatorContext assignment_operator() throws RecognitionException {
Assignment_operatorContext _localctx = new Assignment_operatorContext(_ctx, getState());
enterRule(_localctx, 72, RULE_assignment_operator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(451);
_la = _input.LA(1);
if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 11) | (1L << 16) | (1L << 18) | (1L << 23) | (1L << 24) | (1L << 31) | (1L << 34) | (1L << 36) | (1L << 37) | (1L << 51) | (1L << 52))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Equality_operatorContext extends ParserRuleContext {
public Equality_operatorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_equality_operator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterEquality_operator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitEquality_operator(this);
}
}
@RuleVersion(0)
public final Equality_operatorContext equality_operator() throws RecognitionException {
Equality_operatorContext _localctx = new Equality_operatorContext(_ctx, getState());
enterRule(_localctx, 74, RULE_equality_operator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(453);
_la = _input.LA(1);
if ( !(_la==6 || _la==54) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Template_decl_startContext extends ParserRuleContext {
public TerminalNode TEMPLATE() { return getToken(ModuleParser.TEMPLATE, 0); }
public Template_param_listContext template_param_list() {
return getRuleContext(Template_param_listContext.class,0);
}
public Template_decl_startContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_template_decl_start; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterTemplate_decl_start(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitTemplate_decl_start(this);
}
}
@RuleVersion(0)
public final Template_decl_startContext template_decl_start() throws RecognitionException {
Template_decl_startContext _localctx = new Template_decl_startContext(_ctx, getState());
enterRule(_localctx, 76, RULE_template_decl_start);
try {
enterOuterAlt(_localctx, 1);
{
setState(455); match(TEMPLATE);
setState(456); match(4);
setState(457); template_param_list();
setState(458); match(50);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Template_param_listContext extends ParserRuleContext {
public Template_param_listContext template_param_list(int i) {
return getRuleContext(Template_param_listContext.class,i);
}
public List<? extends No_angle_brackets_or_bracketsContext> no_angle_brackets_or_brackets() {
return getRuleContexts(No_angle_brackets_or_bracketsContext.class);
}
public No_angle_brackets_or_bracketsContext no_angle_brackets_or_brackets(int i) {
return getRuleContext(No_angle_brackets_or_bracketsContext.class,i);
}
public List<? extends Template_param_listContext> template_param_list() {
return getRuleContexts(Template_param_listContext.class);
}
public Template_param_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_template_param_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterTemplate_param_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitTemplate_param_list(this);
}
}
@RuleVersion(0)
public final Template_param_listContext template_param_list() throws RecognitionException {
Template_param_listContext _localctx = new Template_param_listContext(_ctx, getState());
enterRule(_localctx, 78, RULE_template_param_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(469);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
setState(469);
switch (_input.LA(1)) {
case 4:
{
{
setState(460); match(4);
setState(461); template_param_list();
setState(462); match(50);
}
}
break;
case 30:
{
{
setState(464); match(30);
setState(465); template_param_list();
setState(466); match(12);
}
}
break;
case 1:
case 2:
case 3:
case 5:
case 6:
case 7:
case 8:
case 9:
case 10:
case 11:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
case 19:
case 20:
case 21:
case 22:
case 23:
case 24:
case 25:
case 26:
case 27:
case 28:
case 29:
case 31:
case 32:
case 33:
case 34:
case 35:
case 36:
case 37:
case 38:
case 39:
case 40:
case 41:
case 42:
case 43:
case 44:
case 45:
case 46:
case 47:
case 48:
case 49:
case 51:
case 52:
case 53:
case 54:
case 55:
case 56:
case IF:
case ELSE:
case FOR:
case WHILE:
case BREAK:
case CASE:
case CONTINUE:
case SWITCH:
case DO:
case GOTO:
case RETURN:
case TYPEDEF:
case VOID:
case UNSIGNED:
case SIGNED:
case LONG:
case CV_QUALIFIER:
case VIRTUAL:
case TRY:
case CATCH:
case THROW:
case USING:
case NAMESPACE:
case AUTO:
case REGISTER:
case OPERATOR:
case TEMPLATE:
case NEW:
case CLASS_KEY:
case ALPHA_NUMERIC:
case OPENING_CURLY:
case CLOSING_CURLY:
case PRE_IF:
case PRE_ELSE:
case PRE_ENDIF:
case HEX_LITERAL:
case DECIMAL_LITERAL:
case OCTAL_LITERAL:
case FLOATING_POINT_LITERAL:
case CHAR:
case STRING:
case COMMENT:
case WHITESPACE:
case CPPCOMMENT:
case OTHER:
{
setState(468); no_angle_brackets_or_brackets();
}
break;
default:
throw new NoViableAltException(this);
}
}
setState(471);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 3) | (1L << 4) | (1L << 5) | (1L << 6) | (1L << 7) | (1L << 8) | (1L << 9) | (1L << 10) | (1L << 11) | (1L << 13) | (1L << 14) | (1L << 15) | (1L << 16) | (1L << 17) | (1L << 18) | (1L << 19) | (1L << 20) | (1L << 21) | (1L << 22) | (1L << 23) | (1L << 24) | (1L << 25) | (1L << 26) | (1L << 27) | (1L << 28) | (1L << 29) | (1L << 30) | (1L << 31) | (1L << 32) | (1L << 33) | (1L << 34) | (1L << 35) | (1L << 36) | (1L << 37) | (1L << 38) | (1L << 39) | (1L << 40) | (1L << 41) | (1L << 42) | (1L << 43) | (1L << 44) | (1L << 45) | (1L << 46) | (1L << 47) | (1L << 48) | (1L << 49) | (1L << 51) | (1L << 52) | (1L << 53) | (1L << 54) | (1L << 55) | (1L << 56) | (1L << IF) | (1L << ELSE) | (1L << FOR) | (1L << WHILE) | (1L << BREAK) | (1L << CASE) | (1L << CONTINUE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SWITCH - 64)) | (1L << (DO - 64)) | (1L << (GOTO - 64)) | (1L << (RETURN - 64)) | (1L << (TYPEDEF - 64)) | (1L << (VOID - 64)) | (1L << (UNSIGNED - 64)) | (1L << (SIGNED - 64)) | (1L << (LONG - 64)) | (1L << (CV_QUALIFIER - 64)) | (1L << (VIRTUAL - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (THROW - 64)) | (1L << (USING - 64)) | (1L << (NAMESPACE - 64)) | (1L << (AUTO - 64)) | (1L << (REGISTER - 64)) | (1L << (OPERATOR - 64)) | (1L << (TEMPLATE - 64)) | (1L << (NEW - 64)) | (1L << (CLASS_KEY - 64)) | (1L << (ALPHA_NUMERIC - 64)) | (1L << (OPENING_CURLY - 64)) | (1L << (CLOSING_CURLY - 64)) | (1L << (PRE_IF - 64)) | (1L << (PRE_ELSE - 64)) | (1L << (PRE_ENDIF - 64)) | (1L << (HEX_LITERAL - 64)) | (1L << (DECIMAL_LITERAL - 64)) | (1L << (OCTAL_LITERAL - 64)) | (1L << (FLOATING_POINT_LITERAL - 64)) | (1L << (CHAR - 64)) | (1L << (STRING - 64)) | (1L << (COMMENT - 64)) | (1L << (WHITESPACE - 64)) | (1L << (CPPCOMMENT - 64)) | (1L << (OTHER - 64)))) != 0) );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class No_bracketsContext extends ParserRuleContext {
public No_bracketsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_no_brackets; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterNo_brackets(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitNo_brackets(this);
}
}
@RuleVersion(0)
public final No_bracketsContext no_brackets() throws RecognitionException {
No_bracketsContext _localctx = new No_bracketsContext(_ctx, getState());
enterRule(_localctx, 80, RULE_no_brackets);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(473);
_la = _input.LA(1);
if ( _la <= 0 || (_la==12 || _la==30) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class No_brackets_curlies_or_squaresContext extends ParserRuleContext {
public No_brackets_curlies_or_squaresContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_no_brackets_curlies_or_squares; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterNo_brackets_curlies_or_squares(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitNo_brackets_curlies_or_squares(this);
}
}
@RuleVersion(0)
public final No_brackets_curlies_or_squaresContext no_brackets_curlies_or_squares() throws RecognitionException {
No_brackets_curlies_or_squaresContext _localctx = new No_brackets_curlies_or_squaresContext(_ctx, getState());
enterRule(_localctx, 82, RULE_no_brackets_curlies_or_squares);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(475);
_la = _input.LA(1);
if ( _la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 3) | (1L << 12) | (1L << 22) | (1L << 30))) != 0) || _la==OPENING_CURLY || _la==CLOSING_CURLY) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class No_brackets_or_semicolonContext extends ParserRuleContext {
public No_brackets_or_semicolonContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_no_brackets_or_semicolon; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterNo_brackets_or_semicolon(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitNo_brackets_or_semicolon(this);
}
}
@RuleVersion(0)
public final No_brackets_or_semicolonContext no_brackets_or_semicolon() throws RecognitionException {
No_brackets_or_semicolonContext _localctx = new No_brackets_or_semicolonContext(_ctx, getState());
enterRule(_localctx, 84, RULE_no_brackets_or_semicolon);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(477);
_la = _input.LA(1);
if ( _la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 12) | (1L << 30) | (1L << 47))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class No_angle_brackets_or_bracketsContext extends ParserRuleContext {
public No_angle_brackets_or_bracketsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_no_angle_brackets_or_brackets; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterNo_angle_brackets_or_brackets(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitNo_angle_brackets_or_brackets(this);
}
}
@RuleVersion(0)
public final No_angle_brackets_or_bracketsContext no_angle_brackets_or_brackets() throws RecognitionException {
No_angle_brackets_or_bracketsContext _localctx = new No_angle_brackets_or_bracketsContext(_ctx, getState());
enterRule(_localctx, 86, RULE_no_angle_brackets_or_brackets);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(479);
_la = _input.LA(1);
if ( _la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 4) | (1L << 12) | (1L << 30) | (1L << 50))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class No_curliesContext extends ParserRuleContext {
public No_curliesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_no_curlies; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterNo_curlies(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitNo_curlies(this);
}
}
@RuleVersion(0)
public final No_curliesContext no_curlies() throws RecognitionException {
No_curliesContext _localctx = new No_curliesContext(_ctx, getState());
enterRule(_localctx, 88, RULE_no_curlies);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(481);
_la = _input.LA(1);
if ( _la <= 0 || (_la==OPENING_CURLY || _la==CLOSING_CURLY) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class No_squaresContext extends ParserRuleContext {
public No_squaresContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_no_squares; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterNo_squares(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitNo_squares(this);
}
}
@RuleVersion(0)
public final No_squaresContext no_squares() throws RecognitionException {
No_squaresContext _localctx = new No_squaresContext(_ctx, getState());
enterRule(_localctx, 90, RULE_no_squares);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(483);
_la = _input.LA(1);
if ( _la <= 0 || (_la==3 || _la==22) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class No_squares_or_semicolonContext extends ParserRuleContext {
public No_squares_or_semicolonContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_no_squares_or_semicolon; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterNo_squares_or_semicolon(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitNo_squares_or_semicolon(this);
}
}
@RuleVersion(0)
public final No_squares_or_semicolonContext no_squares_or_semicolon() throws RecognitionException {
No_squares_or_semicolonContext _localctx = new No_squares_or_semicolonContext(_ctx, getState());
enterRule(_localctx, 92, RULE_no_squares_or_semicolon);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(485);
_la = _input.LA(1);
if ( _la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 3) | (1L << 22) | (1L << 47))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class No_comma_or_semicolonContext extends ParserRuleContext {
public No_comma_or_semicolonContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_no_comma_or_semicolon; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterNo_comma_or_semicolon(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitNo_comma_or_semicolon(this);
}
}
@RuleVersion(0)
public final No_comma_or_semicolonContext no_comma_or_semicolon() throws RecognitionException {
No_comma_or_semicolonContext _localctx = new No_comma_or_semicolonContext(_ctx, getState());
enterRule(_localctx, 94, RULE_no_comma_or_semicolon);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(487);
_la = _input.LA(1);
if ( _la <= 0 || (_la==27 || _la==47) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Assign_waterContext extends ParserRuleContext {
public Assign_waterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assign_water; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterAssign_water(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitAssign_water(this);
}
}
@RuleVersion(0)
public final Assign_waterContext assign_water() throws RecognitionException {
Assign_waterContext _localctx = new Assign_waterContext(_ctx, getState());
enterRule(_localctx, 96, RULE_assign_water);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(489);
_la = _input.LA(1);
if ( _la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 3) | (1L << 12) | (1L << 22) | (1L << 27) | (1L << 30) | (1L << 47))) != 0) || _la==OPENING_CURLY || _la==CLOSING_CURLY) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Assign_water_l2Context extends ParserRuleContext {
public Assign_water_l2Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assign_water_l2; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterAssign_water_l2(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitAssign_water_l2(this);
}
}
@RuleVersion(0)
public final Assign_water_l2Context assign_water_l2() throws RecognitionException {
Assign_water_l2Context _localctx = new Assign_water_l2Context(_ctx, getState());
enterRule(_localctx, 98, RULE_assign_water_l2);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(491);
_la = _input.LA(1);
if ( _la <= 0 || ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 3) | (1L << 12) | (1L << 22) | (1L << 30))) != 0) || _la==OPENING_CURLY || _la==CLOSING_CURLY) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class WaterContext extends ParserRuleContext {
public WaterContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_water; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterWater(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitWater(this);
}
}
@RuleVersion(0)
public final WaterContext water() throws RecognitionException {
WaterContext _localctx = new WaterContext(_ctx, getState());
enterRule(_localctx, 100, RULE_water);
try {
enterOuterAlt(_localctx, 1);
{
setState(493);
matchWildcard();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Function_defContext extends ParserRuleContext {
public Function_param_listContext function_param_list() {
return getRuleContext(Function_param_listContext.class,0);
}
public Ctor_listContext ctor_list() {
return getRuleContext(Ctor_listContext.class,0);
}
public Return_typeContext return_type() {
return getRuleContext(Return_typeContext.class,0);
}
public Compound_statementContext compound_statement() {
return getRuleContext(Compound_statementContext.class,0);
}
public Template_decl_startContext template_decl_start() {
return getRuleContext(Template_decl_startContext.class,0);
}
public Function_nameContext function_name() {
return getRuleContext(Function_nameContext.class,0);
}
public Function_defContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function_def; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterFunction_def(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitFunction_def(this);
}
}
@RuleVersion(0)
public final Function_defContext function_def() throws RecognitionException {
Function_defContext _localctx = new Function_defContext(_ctx, getState());
enterRule(_localctx, 102, RULE_function_def);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(496);
_la = _input.LA(1);
if (_la==TEMPLATE) {
{
setState(495); template_decl_start();
}
}
setState(499);
switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
case 1:
{
setState(498); return_type();
}
break;
}
setState(501); function_name();
setState(502); function_param_list();
setState(504);
_la = _input.LA(1);
if (_la==29) {
{
setState(503); ctor_list();
}
}
setState(506); compound_statement();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Return_typeContext extends ParserRuleContext {
public Type_nameContext type_name() {
return getRuleContext(Type_nameContext.class,0);
}
public List<? extends Ptr_operatorContext> ptr_operator() {
return getRuleContexts(Ptr_operatorContext.class);
}
public Function_decl_specifiersContext function_decl_specifiers(int i) {
return getRuleContext(Function_decl_specifiersContext.class,i);
}
public List<? extends Function_decl_specifiersContext> function_decl_specifiers() {
return getRuleContexts(Function_decl_specifiersContext.class);
}
public Ptr_operatorContext ptr_operator(int i) {
return getRuleContext(Ptr_operatorContext.class,i);
}
public Return_typeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_return_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterReturn_type(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitReturn_type(this);
}
}
@RuleVersion(0)
public final Return_typeContext return_type() throws RecognitionException {
Return_typeContext _localctx = new Return_typeContext(_ctx, getState());
enterRule(_localctx, 104, RULE_return_type);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
{
setState(511);
_errHandler.sync(this);
_la = _input.LA(1);
while (((((_la - 13)) & ~0x3f) == 0 && ((1L << (_la - 13)) & ((1L << (13 - 13)) | (1L << (14 - 13)) | (1L << (38 - 13)) | (1L << (39 - 13)) | (1L << (VIRTUAL - 13)))) != 0)) {
{
{
setState(508); function_decl_specifiers();
}
}
setState(513);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(514); type_name();
}
setState(519);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==1 || _la==2) {
{
{
setState(516); ptr_operator();
}
}
setState(521);
_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 Function_param_listContext extends ParserRuleContext {
public List<? extends TerminalNode> CV_QUALIFIER() { return getTokens(ModuleParser.CV_QUALIFIER); }
public TerminalNode CV_QUALIFIER(int i) {
return getToken(ModuleParser.CV_QUALIFIER, i);
}
public Exception_specificationContext exception_specification() {
return getRuleContext(Exception_specificationContext.class,0);
}
public Parameter_decl_clauseContext parameter_decl_clause() {
return getRuleContext(Parameter_decl_clauseContext.class,0);
}
public Function_param_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function_param_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterFunction_param_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitFunction_param_list(this);
}
}
@RuleVersion(0)
public final Function_param_listContext function_param_list() throws RecognitionException {
Function_param_listContext _localctx = new Function_param_listContext(_ctx, getState());
enterRule(_localctx, 106, RULE_function_param_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(522); match(30);
setState(524);
_la = _input.LA(1);
if (((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (VOID - 69)) | (1L << (UNSIGNED - 69)) | (1L << (SIGNED - 69)) | (1L << (LONG - 69)) | (1L << (CV_QUALIFIER - 69)) | (1L << (AUTO - 69)) | (1L << (REGISTER - 69)) | (1L << (CLASS_KEY - 69)) | (1L << (ALPHA_NUMERIC - 69)))) != 0)) {
{
setState(523); parameter_decl_clause();
}
}
setState(526); match(12);
setState(530);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CV_QUALIFIER) {
{
{
setState(527); match(CV_QUALIFIER);
}
}
setState(532);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(534);
_la = _input.LA(1);
if (_la==THROW) {
{
setState(533); exception_specification();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Parameter_decl_clauseContext extends ParserRuleContext {
public TerminalNode VOID() { return getToken(ModuleParser.VOID, 0); }
public List<? extends Parameter_declContext> parameter_decl() {
return getRuleContexts(Parameter_declContext.class);
}
public Parameter_declContext parameter_decl(int i) {
return getRuleContext(Parameter_declContext.class,i);
}
public Parameter_decl_clauseContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameter_decl_clause; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterParameter_decl_clause(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitParameter_decl_clause(this);
}
}
@RuleVersion(0)
public final Parameter_decl_clauseContext parameter_decl_clause() throws RecognitionException {
Parameter_decl_clauseContext _localctx = new Parameter_decl_clauseContext(_ctx, getState());
enterRule(_localctx, 108, RULE_parameter_decl_clause);
int _la;
try {
int _alt;
setState(549);
switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
{
setState(536); parameter_decl();
setState(541);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,44,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(537); match(27);
setState(538); parameter_decl();
}
}
}
setState(543);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,44,_ctx);
}
}
setState(546);
_la = _input.LA(1);
if (_la==27) {
{
setState(544); match(27);
setState(545); match(35);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(548); match(VOID);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Parameter_declContext extends ParserRuleContext {
public Parameter_idContext parameter_id() {
return getRuleContext(Parameter_idContext.class,0);
}
public Param_decl_specifiersContext param_decl_specifiers() {
return getRuleContext(Param_decl_specifiersContext.class,0);
}
public Parameter_declContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameter_decl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterParameter_decl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitParameter_decl(this);
}
}
@RuleVersion(0)
public final Parameter_declContext parameter_decl() throws RecognitionException {
Parameter_declContext _localctx = new Parameter_declContext(_ctx, getState());
enterRule(_localctx, 110, RULE_parameter_decl);
try {
enterOuterAlt(_localctx, 1);
{
setState(551); param_decl_specifiers();
setState(552); parameter_id();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Parameter_idContext extends ParserRuleContext {
public PtrsContext ptrs() {
return getRuleContext(PtrsContext.class,0);
}
public Parameter_idContext parameter_id() {
return getRuleContext(Parameter_idContext.class,0);
}
public Parameter_nameContext parameter_name() {
return getRuleContext(Parameter_nameContext.class,0);
}
public Type_suffixContext type_suffix() {
return getRuleContext(Type_suffixContext.class,0);
}
public Parameter_idContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameter_id; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterParameter_id(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitParameter_id(this);
}
}
@RuleVersion(0)
public final Parameter_idContext parameter_id() throws RecognitionException {
Parameter_idContext _localctx = new Parameter_idContext(_ctx, getState());
enterRule(_localctx, 112, RULE_parameter_id);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(555);
_la = _input.LA(1);
if (_la==1 || _la==2) {
{
setState(554); ptrs();
}
}
setState(562);
switch (_input.LA(1)) {
case 30:
{
setState(557); match(30);
setState(558); parameter_id();
setState(559); match(12);
}
break;
case 26:
case 32:
case 46:
case ALPHA_NUMERIC:
{
setState(561); parameter_name();
}
break;
default:
throw new NoViableAltException(this);
}
setState(565);
_la = _input.LA(1);
if (_la==3 || _la==30) {
{
setState(564); type_suffix();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Compound_statementContext extends ParserRuleContext {
public TerminalNode OPENING_CURLY() { return getToken(ModuleParser.OPENING_CURLY, 0); }
public Compound_statementContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_compound_statement; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterCompound_statement(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitCompound_statement(this);
}
}
@RuleVersion(0)
public final Compound_statementContext compound_statement() throws RecognitionException {
Compound_statementContext _localctx = new Compound_statementContext(_ctx, getState());
enterRule(_localctx, 114, RULE_compound_statement);
try {
enterOuterAlt(_localctx, 1);
{
setState(567); match(OPENING_CURLY);
skipToEndOfObject();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Ctor_listContext extends ParserRuleContext {
public List<? extends Ctor_initializerContext> ctor_initializer() {
return getRuleContexts(Ctor_initializerContext.class);
}
public Ctor_initializerContext ctor_initializer(int i) {
return getRuleContext(Ctor_initializerContext.class,i);
}
public Ctor_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ctor_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterCtor_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitCtor_list(this);
}
}
@RuleVersion(0)
public final Ctor_listContext ctor_list() throws RecognitionException {
Ctor_listContext _localctx = new Ctor_listContext(_ctx, getState());
enterRule(_localctx, 116, RULE_ctor_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(570); match(29);
setState(571); ctor_initializer();
setState(576);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==27) {
{
{
setState(572); match(27);
setState(573); ctor_initializer();
}
}
setState(578);
_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 Ctor_initializerContext extends ParserRuleContext {
public Initializer_idContext initializer_id() {
return getRuleContext(Initializer_idContext.class,0);
}
public Ctor_exprContext ctor_expr() {
return getRuleContext(Ctor_exprContext.class,0);
}
public Ctor_initializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ctor_initializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterCtor_initializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitCtor_initializer(this);
}
}
@RuleVersion(0)
public final Ctor_initializerContext ctor_initializer() throws RecognitionException {
Ctor_initializerContext _localctx = new Ctor_initializerContext(_ctx, getState());
enterRule(_localctx, 118, RULE_ctor_initializer);
try {
enterOuterAlt(_localctx, 1);
{
setState(579); initializer_id();
setState(580); ctor_expr();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Initializer_idContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public Initializer_idContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_initializer_id; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterInitializer_id(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitInitializer_id(this);
}
}
@RuleVersion(0)
public final Initializer_idContext initializer_id() throws RecognitionException {
Initializer_idContext _localctx = new Initializer_idContext(_ctx, getState());
enterRule(_localctx, 120, RULE_initializer_id);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(583);
_la = _input.LA(1);
if (_la==15) {
{
setState(582); match(15);
}
}
setState(585); identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Ctor_exprContext extends ParserRuleContext {
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public Ctor_exprContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ctor_expr; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterCtor_expr(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitCtor_expr(this);
}
}
@RuleVersion(0)
public final Ctor_exprContext ctor_expr() throws RecognitionException {
Ctor_exprContext _localctx = new Ctor_exprContext(_ctx, getState());
enterRule(_localctx, 122, RULE_ctor_expr);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(587); match(30);
setState(589);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 5) | (1L << 15) | (1L << 20) | (1L << 21) | (1L << 26) | (1L << 28) | (1L << 30) | (1L << 32) | (1L << 40) | (1L << 45) | (1L << 46) | (1L << 55))) != 0) || ((((_la - 84)) & ~0x3f) == 0 && ((1L << (_la - 84)) & ((1L << (NEW - 84)) | (1L << (ALPHA_NUMERIC - 84)) | (1L << (HEX_LITERAL - 84)) | (1L << (DECIMAL_LITERAL - 84)) | (1L << (OCTAL_LITERAL - 84)) | (1L << (FLOATING_POINT_LITERAL - 84)) | (1L << (CHAR - 84)) | (1L << (STRING - 84)))) != 0)) {
{
setState(588); expr();
}
}
setState(591); match(12);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Function_nameContext extends ParserRuleContext {
public OperatorContext operator() {
return getRuleContext(OperatorContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode OPERATOR() { return getToken(ModuleParser.OPERATOR, 0); }
public Function_nameContext function_name() {
return getRuleContext(Function_nameContext.class,0);
}
public Function_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_function_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterFunction_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitFunction_name(this);
}
}
@RuleVersion(0)
public final Function_nameContext function_name() throws RecognitionException {
Function_nameContext _localctx = new Function_nameContext(_ctx, getState());
enterRule(_localctx, 124, RULE_function_name);
try {
setState(600);
switch (_input.LA(1)) {
case 30:
enterOuterAlt(_localctx, 1);
{
setState(593); match(30);
setState(594); function_name();
setState(595); match(12);
}
break;
case 26:
case 32:
case 46:
case ALPHA_NUMERIC:
enterOuterAlt(_localctx, 2);
{
setState(597); identifier();
}
break;
case OPERATOR:
enterOuterAlt(_localctx, 3);
{
setState(598); match(OPERATOR);
setState(599); operator();
}
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 Exception_specificationContext extends ParserRuleContext {
public Type_id_listContext type_id_list() {
return getRuleContext(Type_id_listContext.class,0);
}
public TerminalNode THROW() { return getToken(ModuleParser.THROW, 0); }
public Exception_specificationContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_exception_specification; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterException_specification(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitException_specification(this);
}
}
@RuleVersion(0)
public final Exception_specificationContext exception_specification() throws RecognitionException {
Exception_specificationContext _localctx = new Exception_specificationContext(_ctx, getState());
enterRule(_localctx, 126, RULE_exception_specification);
try {
enterOuterAlt(_localctx, 1);
{
setState(602); match(THROW);
setState(603); match(30);
setState(604); type_id_list();
setState(605); match(12);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Type_id_listContext extends ParserRuleContext {
public List<? extends Type_id_listContext> type_id_list() {
return getRuleContexts(Type_id_listContext.class);
}
public No_bracketsContext no_brackets(int i) {
return getRuleContext(No_bracketsContext.class,i);
}
public Type_id_listContext type_id_list(int i) {
return getRuleContext(Type_id_listContext.class,i);
}
public List<? extends No_bracketsContext> no_brackets() {
return getRuleContexts(No_bracketsContext.class);
}
public Type_id_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type_id_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterType_id_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitType_id_list(this);
}
}
@RuleVersion(0)
public final Type_id_listContext type_id_list() throws RecognitionException {
Type_id_listContext _localctx = new Type_id_listContext(_ctx, getState());
enterRule(_localctx, 128, RULE_type_id_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(610);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 3) | (1L << 4) | (1L << 5) | (1L << 6) | (1L << 7) | (1L << 8) | (1L << 9) | (1L << 10) | (1L << 11) | (1L << 13) | (1L << 14) | (1L << 15) | (1L << 16) | (1L << 17) | (1L << 18) | (1L << 19) | (1L << 20) | (1L << 21) | (1L << 22) | (1L << 23) | (1L << 24) | (1L << 25) | (1L << 26) | (1L << 27) | (1L << 28) | (1L << 29) | (1L << 31) | (1L << 32) | (1L << 33) | (1L << 34) | (1L << 35) | (1L << 36) | (1L << 37) | (1L << 38) | (1L << 39) | (1L << 40) | (1L << 41) | (1L << 42) | (1L << 43) | (1L << 44) | (1L << 45) | (1L << 46) | (1L << 47) | (1L << 48) | (1L << 49) | (1L << 50) | (1L << 51) | (1L << 52) | (1L << 53) | (1L << 54) | (1L << 55) | (1L << 56) | (1L << IF) | (1L << ELSE) | (1L << FOR) | (1L << WHILE) | (1L << BREAK) | (1L << CASE) | (1L << CONTINUE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SWITCH - 64)) | (1L << (DO - 64)) | (1L << (GOTO - 64)) | (1L << (RETURN - 64)) | (1L << (TYPEDEF - 64)) | (1L << (VOID - 64)) | (1L << (UNSIGNED - 64)) | (1L << (SIGNED - 64)) | (1L << (LONG - 64)) | (1L << (CV_QUALIFIER - 64)) | (1L << (VIRTUAL - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (THROW - 64)) | (1L << (USING - 64)) | (1L << (NAMESPACE - 64)) | (1L << (AUTO - 64)) | (1L << (REGISTER - 64)) | (1L << (OPERATOR - 64)) | (1L << (TEMPLATE - 64)) | (1L << (NEW - 64)) | (1L << (CLASS_KEY - 64)) | (1L << (ALPHA_NUMERIC - 64)) | (1L << (OPENING_CURLY - 64)) | (1L << (CLOSING_CURLY - 64)) | (1L << (PRE_IF - 64)) | (1L << (PRE_ELSE - 64)) | (1L << (PRE_ENDIF - 64)) | (1L << (HEX_LITERAL - 64)) | (1L << (DECIMAL_LITERAL - 64)) | (1L << (OCTAL_LITERAL - 64)) | (1L << (FLOATING_POINT_LITERAL - 64)) | (1L << (CHAR - 64)) | (1L << (STRING - 64)) | (1L << (COMMENT - 64)) | (1L << (WHITESPACE - 64)) | (1L << (CPPCOMMENT - 64)) | (1L << (OTHER - 64)))) != 0)) {
{
{
setState(607); no_brackets();
}
}
setState(612);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(624);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==30) {
{
{
setState(613); match(30);
setState(614); type_id_list();
setState(615); match(12);
setState(619);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 3) | (1L << 4) | (1L << 5) | (1L << 6) | (1L << 7) | (1L << 8) | (1L << 9) | (1L << 10) | (1L << 11) | (1L << 13) | (1L << 14) | (1L << 15) | (1L << 16) | (1L << 17) | (1L << 18) | (1L << 19) | (1L << 20) | (1L << 21) | (1L << 22) | (1L << 23) | (1L << 24) | (1L << 25) | (1L << 26) | (1L << 27) | (1L << 28) | (1L << 29) | (1L << 31) | (1L << 32) | (1L << 33) | (1L << 34) | (1L << 35) | (1L << 36) | (1L << 37) | (1L << 38) | (1L << 39) | (1L << 40) | (1L << 41) | (1L << 42) | (1L << 43) | (1L << 44) | (1L << 45) | (1L << 46) | (1L << 47) | (1L << 48) | (1L << 49) | (1L << 50) | (1L << 51) | (1L << 52) | (1L << 53) | (1L << 54) | (1L << 55) | (1L << 56) | (1L << IF) | (1L << ELSE) | (1L << FOR) | (1L << WHILE) | (1L << BREAK) | (1L << CASE) | (1L << CONTINUE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SWITCH - 64)) | (1L << (DO - 64)) | (1L << (GOTO - 64)) | (1L << (RETURN - 64)) | (1L << (TYPEDEF - 64)) | (1L << (VOID - 64)) | (1L << (UNSIGNED - 64)) | (1L << (SIGNED - 64)) | (1L << (LONG - 64)) | (1L << (CV_QUALIFIER - 64)) | (1L << (VIRTUAL - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (THROW - 64)) | (1L << (USING - 64)) | (1L << (NAMESPACE - 64)) | (1L << (AUTO - 64)) | (1L << (REGISTER - 64)) | (1L << (OPERATOR - 64)) | (1L << (TEMPLATE - 64)) | (1L << (NEW - 64)) | (1L << (CLASS_KEY - 64)) | (1L << (ALPHA_NUMERIC - 64)) | (1L << (OPENING_CURLY - 64)) | (1L << (CLOSING_CURLY - 64)) | (1L << (PRE_IF - 64)) | (1L << (PRE_ELSE - 64)) | (1L << (PRE_ENDIF - 64)) | (1L << (HEX_LITERAL - 64)) | (1L << (DECIMAL_LITERAL - 64)) | (1L << (OCTAL_LITERAL - 64)) | (1L << (FLOATING_POINT_LITERAL - 64)) | (1L << (CHAR - 64)) | (1L << (STRING - 64)) | (1L << (COMMENT - 64)) | (1L << (WHITESPACE - 64)) | (1L << (CPPCOMMENT - 64)) | (1L << (OTHER - 64)))) != 0)) {
{
{
setState(616); no_brackets();
}
}
setState(621);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(626);
_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 Init_declaratorContext extends ParserRuleContext {
public Assign_expr_w_Context assign_expr_w_() {
return getRuleContext(Assign_expr_w_Context.class,0);
}
public ExprContext expr() {
return getRuleContext(ExprContext.class,0);
}
public DeclaratorContext declarator() {
return getRuleContext(DeclaratorContext.class,0);
}
public Init_declaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_init_declarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterInit_declarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitInit_declarator(this);
}
}
@RuleVersion(0)
public final Init_declaratorContext init_declarator() throws RecognitionException {
Init_declaratorContext _localctx = new Init_declaratorContext(_ctx, getState());
enterRule(_localctx, 130, RULE_init_declarator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(627); declarator();
setState(635);
switch (_input.LA(1)) {
case 30:
{
{
setState(628); match(30);
setState(630);
_la = _input.LA(1);
if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 5) | (1L << 15) | (1L << 20) | (1L << 21) | (1L << 26) | (1L << 28) | (1L << 30) | (1L << 32) | (1L << 40) | (1L << 45) | (1L << 46) | (1L << 55))) != 0) || ((((_la - 84)) & ~0x3f) == 0 && ((1L << (_la - 84)) & ((1L << (NEW - 84)) | (1L << (ALPHA_NUMERIC - 84)) | (1L << (HEX_LITERAL - 84)) | (1L << (DECIMAL_LITERAL - 84)) | (1L << (OCTAL_LITERAL - 84)) | (1L << (FLOATING_POINT_LITERAL - 84)) | (1L << (CHAR - 84)) | (1L << (STRING - 84)))) != 0)) {
{
setState(629); expr();
}
}
setState(632); match(12);
}
}
break;
case 16:
{
{
setState(633); match(16);
setState(634); assign_expr_w_();
}
}
break;
case 27:
case 47:
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 DeclaratorContext extends ParserRuleContext {
public PtrsContext ptrs() {
return getRuleContext(PtrsContext.class,0);
}
public Type_suffixContext type_suffix() {
return getRuleContext(Type_suffixContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public DeclaratorContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_declarator; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterDeclarator(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitDeclarator(this);
}
}
@RuleVersion(0)
public final DeclaratorContext declarator() throws RecognitionException {
DeclaratorContext _localctx = new DeclaratorContext(_ctx, getState());
enterRule(_localctx, 132, RULE_declarator);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(638);
_la = _input.LA(1);
if (_la==1 || _la==2) {
{
setState(637); ptrs();
}
}
setState(640); identifier();
setState(642);
switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
case 1:
{
setState(641); type_suffix();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Type_suffixContext extends ParserRuleContext {
public Param_type_listContext param_type_list() {
return getRuleContext(Param_type_listContext.class,0);
}
public Constant_expr_w_Context constant_expr_w_() {
return getRuleContext(Constant_expr_w_Context.class,0);
}
public Type_suffixContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type_suffix; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterType_suffix(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitType_suffix(this);
}
}
@RuleVersion(0)
public final Type_suffixContext type_suffix() throws RecognitionException {
Type_suffixContext _localctx = new Type_suffixContext(_ctx, getState());
enterRule(_localctx, 134, RULE_type_suffix);
try {
setState(649);
switch (_input.LA(1)) {
case 3:
enterOuterAlt(_localctx, 1);
{
{
setState(644); match(3);
setState(645); constant_expr_w_();
setState(646); match(22);
}
}
break;
case 30:
enterOuterAlt(_localctx, 2);
{
setState(648); param_type_list();
}
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 Assign_expr_w_Context extends ParserRuleContext {
public List<? extends Assign_waterContext> assign_water() {
return getRuleContexts(Assign_waterContext.class);
}
public List<? extends Assign_expr_w__l2Context> assign_expr_w__l2() {
return getRuleContexts(Assign_expr_w__l2Context.class);
}
public Assign_waterContext assign_water(int i) {
return getRuleContext(Assign_waterContext.class,i);
}
public Assign_expr_w__l2Context assign_expr_w__l2(int i) {
return getRuleContext(Assign_expr_w__l2Context.class,i);
}
public Assign_expr_w_Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assign_expr_w_; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterAssign_expr_w_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitAssign_expr_w_(this);
}
}
@RuleVersion(0)
public final Assign_expr_w_Context assign_expr_w_() throws RecognitionException {
Assign_expr_w_Context _localctx = new Assign_expr_w_Context(_ctx, getState());
enterRule(_localctx, 136, RULE_assign_expr_w_);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(654);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 4) | (1L << 5) | (1L << 6) | (1L << 7) | (1L << 8) | (1L << 9) | (1L << 10) | (1L << 11) | (1L << 13) | (1L << 14) | (1L << 15) | (1L << 16) | (1L << 17) | (1L << 18) | (1L << 19) | (1L << 20) | (1L << 21) | (1L << 23) | (1L << 24) | (1L << 25) | (1L << 26) | (1L << 28) | (1L << 29) | (1L << 31) | (1L << 32) | (1L << 33) | (1L << 34) | (1L << 35) | (1L << 36) | (1L << 37) | (1L << 38) | (1L << 39) | (1L << 40) | (1L << 41) | (1L << 42) | (1L << 43) | (1L << 44) | (1L << 45) | (1L << 46) | (1L << 48) | (1L << 49) | (1L << 50) | (1L << 51) | (1L << 52) | (1L << 53) | (1L << 54) | (1L << 55) | (1L << 56) | (1L << IF) | (1L << ELSE) | (1L << FOR) | (1L << WHILE) | (1L << BREAK) | (1L << CASE) | (1L << CONTINUE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SWITCH - 64)) | (1L << (DO - 64)) | (1L << (GOTO - 64)) | (1L << (RETURN - 64)) | (1L << (TYPEDEF - 64)) | (1L << (VOID - 64)) | (1L << (UNSIGNED - 64)) | (1L << (SIGNED - 64)) | (1L << (LONG - 64)) | (1L << (CV_QUALIFIER - 64)) | (1L << (VIRTUAL - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (THROW - 64)) | (1L << (USING - 64)) | (1L << (NAMESPACE - 64)) | (1L << (AUTO - 64)) | (1L << (REGISTER - 64)) | (1L << (OPERATOR - 64)) | (1L << (TEMPLATE - 64)) | (1L << (NEW - 64)) | (1L << (CLASS_KEY - 64)) | (1L << (ALPHA_NUMERIC - 64)) | (1L << (PRE_IF - 64)) | (1L << (PRE_ELSE - 64)) | (1L << (PRE_ENDIF - 64)) | (1L << (HEX_LITERAL - 64)) | (1L << (DECIMAL_LITERAL - 64)) | (1L << (OCTAL_LITERAL - 64)) | (1L << (FLOATING_POINT_LITERAL - 64)) | (1L << (CHAR - 64)) | (1L << (STRING - 64)) | (1L << (COMMENT - 64)) | (1L << (WHITESPACE - 64)) | (1L << (CPPCOMMENT - 64)) | (1L << (OTHER - 64)))) != 0)) {
{
{
setState(651); assign_water();
}
}
setState(656);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(679);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==3 || _la==30 || _la==OPENING_CURLY) {
{
{
setState(669);
switch (_input.LA(1)) {
case OPENING_CURLY:
{
setState(657); match(OPENING_CURLY);
setState(658); assign_expr_w__l2();
setState(659); match(CLOSING_CURLY);
}
break;
case 30:
{
setState(661); match(30);
setState(662); assign_expr_w__l2();
setState(663); match(12);
}
break;
case 3:
{
setState(665); match(3);
setState(666); assign_expr_w__l2();
setState(667); match(22);
}
break;
default:
throw new NoViableAltException(this);
}
setState(674);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 4) | (1L << 5) | (1L << 6) | (1L << 7) | (1L << 8) | (1L << 9) | (1L << 10) | (1L << 11) | (1L << 13) | (1L << 14) | (1L << 15) | (1L << 16) | (1L << 17) | (1L << 18) | (1L << 19) | (1L << 20) | (1L << 21) | (1L << 23) | (1L << 24) | (1L << 25) | (1L << 26) | (1L << 28) | (1L << 29) | (1L << 31) | (1L << 32) | (1L << 33) | (1L << 34) | (1L << 35) | (1L << 36) | (1L << 37) | (1L << 38) | (1L << 39) | (1L << 40) | (1L << 41) | (1L << 42) | (1L << 43) | (1L << 44) | (1L << 45) | (1L << 46) | (1L << 48) | (1L << 49) | (1L << 50) | (1L << 51) | (1L << 52) | (1L << 53) | (1L << 54) | (1L << 55) | (1L << 56) | (1L << IF) | (1L << ELSE) | (1L << FOR) | (1L << WHILE) | (1L << BREAK) | (1L << CASE) | (1L << CONTINUE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SWITCH - 64)) | (1L << (DO - 64)) | (1L << (GOTO - 64)) | (1L << (RETURN - 64)) | (1L << (TYPEDEF - 64)) | (1L << (VOID - 64)) | (1L << (UNSIGNED - 64)) | (1L << (SIGNED - 64)) | (1L << (LONG - 64)) | (1L << (CV_QUALIFIER - 64)) | (1L << (VIRTUAL - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (THROW - 64)) | (1L << (USING - 64)) | (1L << (NAMESPACE - 64)) | (1L << (AUTO - 64)) | (1L << (REGISTER - 64)) | (1L << (OPERATOR - 64)) | (1L << (TEMPLATE - 64)) | (1L << (NEW - 64)) | (1L << (CLASS_KEY - 64)) | (1L << (ALPHA_NUMERIC - 64)) | (1L << (PRE_IF - 64)) | (1L << (PRE_ELSE - 64)) | (1L << (PRE_ENDIF - 64)) | (1L << (HEX_LITERAL - 64)) | (1L << (DECIMAL_LITERAL - 64)) | (1L << (OCTAL_LITERAL - 64)) | (1L << (FLOATING_POINT_LITERAL - 64)) | (1L << (CHAR - 64)) | (1L << (STRING - 64)) | (1L << (COMMENT - 64)) | (1L << (WHITESPACE - 64)) | (1L << (CPPCOMMENT - 64)) | (1L << (OTHER - 64)))) != 0)) {
{
{
setState(671); assign_water();
}
}
setState(676);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(681);
_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 Assign_expr_w__l2Context extends ParserRuleContext {
public List<? extends Assign_expr_w__l2Context> assign_expr_w__l2() {
return getRuleContexts(Assign_expr_w__l2Context.class);
}
public Assign_water_l2Context assign_water_l2(int i) {
return getRuleContext(Assign_water_l2Context.class,i);
}
public List<? extends Assign_water_l2Context> assign_water_l2() {
return getRuleContexts(Assign_water_l2Context.class);
}
public Assign_expr_w__l2Context assign_expr_w__l2(int i) {
return getRuleContext(Assign_expr_w__l2Context.class,i);
}
public Assign_expr_w__l2Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_assign_expr_w__l2; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterAssign_expr_w__l2(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitAssign_expr_w__l2(this);
}
}
@RuleVersion(0)
public final Assign_expr_w__l2Context assign_expr_w__l2() throws RecognitionException {
Assign_expr_w__l2Context _localctx = new Assign_expr_w__l2Context(_ctx, getState());
enterRule(_localctx, 138, RULE_assign_expr_w__l2);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(685);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 4) | (1L << 5) | (1L << 6) | (1L << 7) | (1L << 8) | (1L << 9) | (1L << 10) | (1L << 11) | (1L << 13) | (1L << 14) | (1L << 15) | (1L << 16) | (1L << 17) | (1L << 18) | (1L << 19) | (1L << 20) | (1L << 21) | (1L << 23) | (1L << 24) | (1L << 25) | (1L << 26) | (1L << 27) | (1L << 28) | (1L << 29) | (1L << 31) | (1L << 32) | (1L << 33) | (1L << 34) | (1L << 35) | (1L << 36) | (1L << 37) | (1L << 38) | (1L << 39) | (1L << 40) | (1L << 41) | (1L << 42) | (1L << 43) | (1L << 44) | (1L << 45) | (1L << 46) | (1L << 47) | (1L << 48) | (1L << 49) | (1L << 50) | (1L << 51) | (1L << 52) | (1L << 53) | (1L << 54) | (1L << 55) | (1L << 56) | (1L << IF) | (1L << ELSE) | (1L << FOR) | (1L << WHILE) | (1L << BREAK) | (1L << CASE) | (1L << CONTINUE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SWITCH - 64)) | (1L << (DO - 64)) | (1L << (GOTO - 64)) | (1L << (RETURN - 64)) | (1L << (TYPEDEF - 64)) | (1L << (VOID - 64)) | (1L << (UNSIGNED - 64)) | (1L << (SIGNED - 64)) | (1L << (LONG - 64)) | (1L << (CV_QUALIFIER - 64)) | (1L << (VIRTUAL - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (THROW - 64)) | (1L << (USING - 64)) | (1L << (NAMESPACE - 64)) | (1L << (AUTO - 64)) | (1L << (REGISTER - 64)) | (1L << (OPERATOR - 64)) | (1L << (TEMPLATE - 64)) | (1L << (NEW - 64)) | (1L << (CLASS_KEY - 64)) | (1L << (ALPHA_NUMERIC - 64)) | (1L << (PRE_IF - 64)) | (1L << (PRE_ELSE - 64)) | (1L << (PRE_ENDIF - 64)) | (1L << (HEX_LITERAL - 64)) | (1L << (DECIMAL_LITERAL - 64)) | (1L << (OCTAL_LITERAL - 64)) | (1L << (FLOATING_POINT_LITERAL - 64)) | (1L << (CHAR - 64)) | (1L << (STRING - 64)) | (1L << (COMMENT - 64)) | (1L << (WHITESPACE - 64)) | (1L << (CPPCOMMENT - 64)) | (1L << (OTHER - 64)))) != 0)) {
{
{
setState(682); assign_water_l2();
}
}
setState(687);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(710);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==3 || _la==30 || _la==OPENING_CURLY) {
{
{
setState(700);
switch (_input.LA(1)) {
case OPENING_CURLY:
{
setState(688); match(OPENING_CURLY);
setState(689); assign_expr_w__l2();
setState(690); match(CLOSING_CURLY);
}
break;
case 30:
{
setState(692); match(30);
setState(693); assign_expr_w__l2();
setState(694); match(12);
}
break;
case 3:
{
setState(696); match(3);
setState(697); assign_expr_w__l2();
setState(698); match(22);
}
break;
default:
throw new NoViableAltException(this);
}
setState(705);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 4) | (1L << 5) | (1L << 6) | (1L << 7) | (1L << 8) | (1L << 9) | (1L << 10) | (1L << 11) | (1L << 13) | (1L << 14) | (1L << 15) | (1L << 16) | (1L << 17) | (1L << 18) | (1L << 19) | (1L << 20) | (1L << 21) | (1L << 23) | (1L << 24) | (1L << 25) | (1L << 26) | (1L << 27) | (1L << 28) | (1L << 29) | (1L << 31) | (1L << 32) | (1L << 33) | (1L << 34) | (1L << 35) | (1L << 36) | (1L << 37) | (1L << 38) | (1L << 39) | (1L << 40) | (1L << 41) | (1L << 42) | (1L << 43) | (1L << 44) | (1L << 45) | (1L << 46) | (1L << 47) | (1L << 48) | (1L << 49) | (1L << 50) | (1L << 51) | (1L << 52) | (1L << 53) | (1L << 54) | (1L << 55) | (1L << 56) | (1L << IF) | (1L << ELSE) | (1L << FOR) | (1L << WHILE) | (1L << BREAK) | (1L << CASE) | (1L << CONTINUE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SWITCH - 64)) | (1L << (DO - 64)) | (1L << (GOTO - 64)) | (1L << (RETURN - 64)) | (1L << (TYPEDEF - 64)) | (1L << (VOID - 64)) | (1L << (UNSIGNED - 64)) | (1L << (SIGNED - 64)) | (1L << (LONG - 64)) | (1L << (CV_QUALIFIER - 64)) | (1L << (VIRTUAL - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (THROW - 64)) | (1L << (USING - 64)) | (1L << (NAMESPACE - 64)) | (1L << (AUTO - 64)) | (1L << (REGISTER - 64)) | (1L << (OPERATOR - 64)) | (1L << (TEMPLATE - 64)) | (1L << (NEW - 64)) | (1L << (CLASS_KEY - 64)) | (1L << (ALPHA_NUMERIC - 64)) | (1L << (PRE_IF - 64)) | (1L << (PRE_ELSE - 64)) | (1L << (PRE_ENDIF - 64)) | (1L << (HEX_LITERAL - 64)) | (1L << (DECIMAL_LITERAL - 64)) | (1L << (OCTAL_LITERAL - 64)) | (1L << (FLOATING_POINT_LITERAL - 64)) | (1L << (CHAR - 64)) | (1L << (STRING - 64)) | (1L << (COMMENT - 64)) | (1L << (WHITESPACE - 64)) | (1L << (CPPCOMMENT - 64)) | (1L << (OTHER - 64)))) != 0)) {
{
{
setState(702); assign_water_l2();
}
}
setState(707);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(712);
_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 Constant_expr_w_Context extends ParserRuleContext {
public No_squaresContext no_squares(int i) {
return getRuleContext(No_squaresContext.class,i);
}
public List<? extends No_squaresContext> no_squares() {
return getRuleContexts(No_squaresContext.class);
}
public List<? extends Constant_expr_w_Context> constant_expr_w_() {
return getRuleContexts(Constant_expr_w_Context.class);
}
public Constant_expr_w_Context constant_expr_w_(int i) {
return getRuleContext(Constant_expr_w_Context.class,i);
}
public Constant_expr_w_Context(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_constant_expr_w_; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterConstant_expr_w_(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitConstant_expr_w_(this);
}
}
@RuleVersion(0)
public final Constant_expr_w_Context constant_expr_w_() throws RecognitionException {
Constant_expr_w_Context _localctx = new Constant_expr_w_Context(_ctx, getState());
enterRule(_localctx, 140, RULE_constant_expr_w_);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(716);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 4) | (1L << 5) | (1L << 6) | (1L << 7) | (1L << 8) | (1L << 9) | (1L << 10) | (1L << 11) | (1L << 12) | (1L << 13) | (1L << 14) | (1L << 15) | (1L << 16) | (1L << 17) | (1L << 18) | (1L << 19) | (1L << 20) | (1L << 21) | (1L << 23) | (1L << 24) | (1L << 25) | (1L << 26) | (1L << 27) | (1L << 28) | (1L << 29) | (1L << 30) | (1L << 31) | (1L << 32) | (1L << 33) | (1L << 34) | (1L << 35) | (1L << 36) | (1L << 37) | (1L << 38) | (1L << 39) | (1L << 40) | (1L << 41) | (1L << 42) | (1L << 43) | (1L << 44) | (1L << 45) | (1L << 46) | (1L << 47) | (1L << 48) | (1L << 49) | (1L << 50) | (1L << 51) | (1L << 52) | (1L << 53) | (1L << 54) | (1L << 55) | (1L << 56) | (1L << IF) | (1L << ELSE) | (1L << FOR) | (1L << WHILE) | (1L << BREAK) | (1L << CASE) | (1L << CONTINUE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SWITCH - 64)) | (1L << (DO - 64)) | (1L << (GOTO - 64)) | (1L << (RETURN - 64)) | (1L << (TYPEDEF - 64)) | (1L << (VOID - 64)) | (1L << (UNSIGNED - 64)) | (1L << (SIGNED - 64)) | (1L << (LONG - 64)) | (1L << (CV_QUALIFIER - 64)) | (1L << (VIRTUAL - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (THROW - 64)) | (1L << (USING - 64)) | (1L << (NAMESPACE - 64)) | (1L << (AUTO - 64)) | (1L << (REGISTER - 64)) | (1L << (OPERATOR - 64)) | (1L << (TEMPLATE - 64)) | (1L << (NEW - 64)) | (1L << (CLASS_KEY - 64)) | (1L << (ALPHA_NUMERIC - 64)) | (1L << (OPENING_CURLY - 64)) | (1L << (CLOSING_CURLY - 64)) | (1L << (PRE_IF - 64)) | (1L << (PRE_ELSE - 64)) | (1L << (PRE_ENDIF - 64)) | (1L << (HEX_LITERAL - 64)) | (1L << (DECIMAL_LITERAL - 64)) | (1L << (OCTAL_LITERAL - 64)) | (1L << (FLOATING_POINT_LITERAL - 64)) | (1L << (CHAR - 64)) | (1L << (STRING - 64)) | (1L << (COMMENT - 64)) | (1L << (WHITESPACE - 64)) | (1L << (CPPCOMMENT - 64)) | (1L << (OTHER - 64)))) != 0)) {
{
{
setState(713); no_squares();
}
}
setState(718);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(730);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==3) {
{
{
setState(719); match(3);
setState(720); constant_expr_w_();
setState(721); match(22);
setState(725);
_errHandler.sync(this);
_la = _input.LA(1);
while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << 1) | (1L << 2) | (1L << 4) | (1L << 5) | (1L << 6) | (1L << 7) | (1L << 8) | (1L << 9) | (1L << 10) | (1L << 11) | (1L << 12) | (1L << 13) | (1L << 14) | (1L << 15) | (1L << 16) | (1L << 17) | (1L << 18) | (1L << 19) | (1L << 20) | (1L << 21) | (1L << 23) | (1L << 24) | (1L << 25) | (1L << 26) | (1L << 27) | (1L << 28) | (1L << 29) | (1L << 30) | (1L << 31) | (1L << 32) | (1L << 33) | (1L << 34) | (1L << 35) | (1L << 36) | (1L << 37) | (1L << 38) | (1L << 39) | (1L << 40) | (1L << 41) | (1L << 42) | (1L << 43) | (1L << 44) | (1L << 45) | (1L << 46) | (1L << 47) | (1L << 48) | (1L << 49) | (1L << 50) | (1L << 51) | (1L << 52) | (1L << 53) | (1L << 54) | (1L << 55) | (1L << 56) | (1L << IF) | (1L << ELSE) | (1L << FOR) | (1L << WHILE) | (1L << BREAK) | (1L << CASE) | (1L << CONTINUE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (SWITCH - 64)) | (1L << (DO - 64)) | (1L << (GOTO - 64)) | (1L << (RETURN - 64)) | (1L << (TYPEDEF - 64)) | (1L << (VOID - 64)) | (1L << (UNSIGNED - 64)) | (1L << (SIGNED - 64)) | (1L << (LONG - 64)) | (1L << (CV_QUALIFIER - 64)) | (1L << (VIRTUAL - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (THROW - 64)) | (1L << (USING - 64)) | (1L << (NAMESPACE - 64)) | (1L << (AUTO - 64)) | (1L << (REGISTER - 64)) | (1L << (OPERATOR - 64)) | (1L << (TEMPLATE - 64)) | (1L << (NEW - 64)) | (1L << (CLASS_KEY - 64)) | (1L << (ALPHA_NUMERIC - 64)) | (1L << (OPENING_CURLY - 64)) | (1L << (CLOSING_CURLY - 64)) | (1L << (PRE_IF - 64)) | (1L << (PRE_ELSE - 64)) | (1L << (PRE_ENDIF - 64)) | (1L << (HEX_LITERAL - 64)) | (1L << (DECIMAL_LITERAL - 64)) | (1L << (OCTAL_LITERAL - 64)) | (1L << (FLOATING_POINT_LITERAL - 64)) | (1L << (CHAR - 64)) | (1L << (STRING - 64)) | (1L << (COMMENT - 64)) | (1L << (WHITESPACE - 64)) | (1L << (CPPCOMMENT - 64)) | (1L << (OTHER - 64)))) != 0)) {
{
{
setState(722); no_squares();
}
}
setState(727);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(732);
_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 Simple_declContext extends ParserRuleContext {
public TerminalNode TYPEDEF() { return getToken(ModuleParser.TYPEDEF, 0); }
public Var_declContext var_decl() {
return getRuleContext(Var_declContext.class,0);
}
public Template_decl_startContext template_decl_start() {
return getRuleContext(Template_decl_startContext.class,0);
}
public Simple_declContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_simple_decl; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterSimple_decl(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitSimple_decl(this);
}
}
@RuleVersion(0)
public final Simple_declContext simple_decl() throws RecognitionException {
Simple_declContext _localctx = new Simple_declContext(_ctx, getState());
enterRule(_localctx, 142, RULE_simple_decl);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
{
setState(734);
_la = _input.LA(1);
if (_la==TYPEDEF) {
{
setState(733); match(TYPEDEF);
}
}
setState(737);
_la = _input.LA(1);
if (_la==TEMPLATE) {
{
setState(736); template_decl_start();
}
}
}
setState(739); var_decl();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Var_declContext extends ParserRuleContext {
public Var_declContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_var_decl; }
public Var_declContext() { }
public void copyFrom(Var_declContext ctx) {
super.copyFrom(ctx);
}
}
public static class DeclByClassContext extends Var_declContext {
public Init_declarator_listContext init_declarator_list() {
return getRuleContext(Init_declarator_listContext.class,0);
}
public Class_defContext class_def() {
return getRuleContext(Class_defContext.class,0);
}
public DeclByClassContext(Var_declContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterDeclByClass(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitDeclByClass(this);
}
}
public static class DeclByTypeContext extends Var_declContext {
public Type_nameContext type_name() {
return getRuleContext(Type_nameContext.class,0);
}
public Init_declarator_listContext init_declarator_list() {
return getRuleContext(Init_declarator_listContext.class,0);
}
public DeclByTypeContext(Var_declContext ctx) { copyFrom(ctx); }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterDeclByType(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitDeclByType(this);
}
}
@RuleVersion(0)
public final Var_declContext var_decl() throws RecognitionException {
Var_declContext _localctx = new Var_declContext(_ctx, getState());
enterRule(_localctx, 144, RULE_var_decl);
try {
setState(748);
switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
case 1:
_localctx = new DeclByClassContext(_localctx);
enterOuterAlt(_localctx, 1);
{
setState(741); class_def();
setState(743);
switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) {
case 1:
{
setState(742); init_declarator_list();
}
break;
}
}
break;
case 2:
_localctx = new DeclByTypeContext(_localctx);
enterOuterAlt(_localctx, 2);
{
setState(745); type_name();
setState(746); init_declarator_list();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Init_declarator_listContext extends ParserRuleContext {
public Init_declaratorContext init_declarator(int i) {
return getRuleContext(Init_declaratorContext.class,i);
}
public List<? extends Init_declaratorContext> init_declarator() {
return getRuleContexts(Init_declaratorContext.class);
}
public Init_declarator_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_init_declarator_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterInit_declarator_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitInit_declarator_list(this);
}
}
@RuleVersion(0)
public final Init_declarator_listContext init_declarator_list() throws RecognitionException {
Init_declarator_listContext _localctx = new Init_declarator_listContext(_ctx, getState());
enterRule(_localctx, 146, RULE_init_declarator_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(750); init_declarator();
setState(755);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==27) {
{
{
setState(751); match(27);
setState(752); init_declarator();
}
}
setState(757);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(758); match(47);
}
}
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 Assign_exprContext assign_expr() {
return getRuleContext(Assign_exprContext.class,0);
}
public Initializer_listContext initializer_list() {
return getRuleContext(Initializer_listContext.class,0);
}
public InitializerContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_initializer; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterInitializer(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitInitializer(this);
}
}
@RuleVersion(0)
public final InitializerContext initializer() throws RecognitionException {
InitializerContext _localctx = new InitializerContext(_ctx, getState());
enterRule(_localctx, 148, RULE_initializer);
try {
setState(765);
switch (_input.LA(1)) {
case 1:
case 2:
case 5:
case 15:
case 20:
case 21:
case 26:
case 28:
case 30:
case 32:
case 40:
case 45:
case 46:
case 55:
case NEW:
case ALPHA_NUMERIC:
case HEX_LITERAL:
case DECIMAL_LITERAL:
case OCTAL_LITERAL:
case FLOATING_POINT_LITERAL:
case CHAR:
case STRING:
enterOuterAlt(_localctx, 1);
{
setState(760); assign_expr();
}
break;
case OPENING_CURLY:
enterOuterAlt(_localctx, 2);
{
setState(761); match(OPENING_CURLY);
setState(762); initializer_list();
setState(763); match(CLOSING_CURLY);
}
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 Initializer_listContext extends ParserRuleContext {
public List<? extends InitializerContext> initializer() {
return getRuleContexts(InitializerContext.class);
}
public InitializerContext initializer(int i) {
return getRuleContext(InitializerContext.class,i);
}
public Initializer_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_initializer_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterInitializer_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitInitializer_list(this);
}
}
@RuleVersion(0)
public final Initializer_listContext initializer_list() throws RecognitionException {
Initializer_listContext _localctx = new Initializer_listContext(_ctx, getState());
enterRule(_localctx, 150, RULE_initializer_list);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(767); initializer();
setState(772);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==27) {
{
{
setState(768); match(27);
setState(769); initializer();
}
}
setState(774);
_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 Class_defContext extends ParserRuleContext {
public TerminalNode CLASS_KEY() { return getToken(ModuleParser.CLASS_KEY, 0); }
public TerminalNode OPENING_CURLY() { return getToken(ModuleParser.OPENING_CURLY, 0); }
public Base_classesContext base_classes() {
return getRuleContext(Base_classesContext.class,0);
}
public Class_nameContext class_name() {
return getRuleContext(Class_nameContext.class,0);
}
public Class_defContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_class_def; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterClass_def(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitClass_def(this);
}
}
@RuleVersion(0)
public final Class_defContext class_def() throws RecognitionException {
Class_defContext _localctx = new Class_defContext(_ctx, getState());
enterRule(_localctx, 152, RULE_class_def);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(775); match(CLASS_KEY);
setState(777);
_la = _input.LA(1);
if (((((_la - 26)) & ~0x3f) == 0 && ((1L << (_la - 26)) & ((1L << (26 - 26)) | (1L << (32 - 26)) | (1L << (46 - 26)) | (1L << (ALPHA_NUMERIC - 26)))) != 0)) {
{
setState(776); class_name();
}
}
setState(780);
_la = _input.LA(1);
if (_la==29) {
{
setState(779); base_classes();
}
}
setState(782); match(OPENING_CURLY);
skipToEndOfObject();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Class_nameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public Class_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_class_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterClass_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitClass_name(this);
}
}
@RuleVersion(0)
public final Class_nameContext class_name() throws RecognitionException {
Class_nameContext _localctx = new Class_nameContext(_ctx, getState());
enterRule(_localctx, 154, RULE_class_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(785); identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Base_classesContext extends ParserRuleContext {
public List<? extends Base_classContext> base_class() {
return getRuleContexts(Base_classContext.class);
}
public Base_classContext base_class(int i) {
return getRuleContext(Base_classContext.class,i);
}
public Base_classesContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_base_classes; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterBase_classes(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitBase_classes(this);
}
}
@RuleVersion(0)
public final Base_classesContext base_classes() throws RecognitionException {
Base_classesContext _localctx = new Base_classesContext(_ctx, getState());
enterRule(_localctx, 156, RULE_base_classes);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(787); match(29);
setState(788); base_class();
setState(793);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==27) {
{
{
setState(789); match(27);
setState(790); base_class();
}
}
setState(795);
_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 Base_classContext extends ParserRuleContext {
public Access_specifierContext access_specifier() {
return getRuleContext(Access_specifierContext.class,0);
}
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public TerminalNode VIRTUAL() { return getToken(ModuleParser.VIRTUAL, 0); }
public Base_classContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_base_class; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterBase_class(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitBase_class(this);
}
}
@RuleVersion(0)
public final Base_classContext base_class() throws RecognitionException {
Base_classContext _localctx = new Base_classContext(_ctx, getState());
enterRule(_localctx, 158, RULE_base_class);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(797);
_la = _input.LA(1);
if (_la==VIRTUAL) {
{
setState(796); match(VIRTUAL);
}
}
setState(800);
switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) {
case 1:
{
setState(799); access_specifier();
}
break;
}
setState(802); identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Type_nameContext extends ParserRuleContext {
public List<? extends TerminalNode> CV_QUALIFIER() { return getTokens(ModuleParser.CV_QUALIFIER); }
public TerminalNode CLASS_KEY() { return getToken(ModuleParser.CLASS_KEY, 0); }
public Template_param_listContext template_param_list(int i) {
return getRuleContext(Template_param_listContext.class,i);
}
public TerminalNode SIGNED() { return getToken(ModuleParser.SIGNED, 0); }
public TerminalNode CV_QUALIFIER(int i) {
return getToken(ModuleParser.CV_QUALIFIER, i);
}
public Base_typeContext base_type(int i) {
return getRuleContext(Base_typeContext.class,i);
}
public List<? extends Base_typeContext> base_type() {
return getRuleContexts(Base_typeContext.class);
}
public TerminalNode UNSIGNED() { return getToken(ModuleParser.UNSIGNED, 0); }
public List<? extends Template_param_listContext> template_param_list() {
return getRuleContexts(Template_param_listContext.class);
}
public Type_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_type_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterType_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitType_name(this);
}
}
@RuleVersion(0)
public final Type_nameContext type_name() throws RecognitionException {
Type_nameContext _localctx = new Type_nameContext(_ctx, getState());
enterRule(_localctx, 160, RULE_type_name);
int _la;
try {
setState(838);
switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
{
setState(807);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==CV_QUALIFIER) {
{
{
setState(804); match(CV_QUALIFIER);
}
}
setState(809);
_errHandler.sync(this);
_la = _input.LA(1);
}
setState(811);
_la = _input.LA(1);
if (((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (UNSIGNED - 70)) | (1L << (SIGNED - 70)) | (1L << (CLASS_KEY - 70)))) != 0)) {
{
setState(810);
_la = _input.LA(1);
if ( !(((((_la - 70)) & ~0x3f) == 0 && ((1L << (_la - 70)) & ((1L << (UNSIGNED - 70)) | (1L << (SIGNED - 70)) | (1L << (CLASS_KEY - 70)))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
setState(813); base_type();
setState(818);
_la = _input.LA(1);
if (_la==4) {
{
setState(814); match(4);
setState(815); template_param_list();
setState(816); match(50);
}
}
setState(830);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==15) {
{
{
setState(820); match(15);
setState(821); base_type();
setState(826);
_la = _input.LA(1);
if (_la==4) {
{
setState(822); match(4);
setState(823); template_param_list();
setState(824); match(50);
}
}
}
}
setState(832);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
setState(834);
_la = _input.LA(1);
if (_la==CV_QUALIFIER) {
{
setState(833); match(CV_QUALIFIER);
}
}
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(836); match(UNSIGNED);
}
break;
case 3:
enterOuterAlt(_localctx, 3);
{
setState(837); match(SIGNED);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Base_typeContext extends ParserRuleContext {
public List<? extends TerminalNode> ALPHA_NUMERIC() { return getTokens(ModuleParser.ALPHA_NUMERIC); }
public List<? extends TerminalNode> LONG() { return getTokens(ModuleParser.LONG); }
public TerminalNode VOID(int i) {
return getToken(ModuleParser.VOID, i);
}
public List<? extends TerminalNode> VOID() { return getTokens(ModuleParser.VOID); }
public TerminalNode LONG(int i) {
return getToken(ModuleParser.LONG, i);
}
public TerminalNode ALPHA_NUMERIC(int i) {
return getToken(ModuleParser.ALPHA_NUMERIC, i);
}
public Base_typeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_base_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterBase_type(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitBase_type(this);
}
}
@RuleVersion(0)
public final Base_typeContext base_type() throws RecognitionException {
Base_typeContext _localctx = new Base_typeContext(_ctx, getState());
enterRule(_localctx, 162, RULE_base_type);
int _la;
try {
int _alt;
enterOuterAlt(_localctx, 1);
{
setState(841);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,92,_ctx);
do {
switch (_alt) {
case 1:
{
{
setState(840);
_la = _input.LA(1);
if ( !(((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (VOID - 69)) | (1L << (LONG - 69)) | (1L << (ALPHA_NUMERIC - 69)))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
break;
default:
throw new NoViableAltException(this);
}
setState(843);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,92,_ctx);
} while ( _alt!=2 && _alt!=-1 );
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Param_decl_specifiersContext extends ParserRuleContext {
public Type_nameContext type_name() {
return getRuleContext(Type_nameContext.class,0);
}
public TerminalNode AUTO() { return getToken(ModuleParser.AUTO, 0); }
public TerminalNode REGISTER() { return getToken(ModuleParser.REGISTER, 0); }
public Param_decl_specifiersContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_param_decl_specifiers; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterParam_decl_specifiers(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitParam_decl_specifiers(this);
}
}
@RuleVersion(0)
public final Param_decl_specifiersContext param_decl_specifiers() throws RecognitionException {
Param_decl_specifiersContext _localctx = new Param_decl_specifiersContext(_ctx, getState());
enterRule(_localctx, 164, RULE_param_decl_specifiers);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(846);
_la = _input.LA(1);
if (_la==AUTO || _la==REGISTER) {
{
setState(845);
_la = _input.LA(1);
if ( !(_la==AUTO || _la==REGISTER) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
setState(848); type_name();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Parameter_nameContext extends ParserRuleContext {
public IdentifierContext identifier() {
return getRuleContext(IdentifierContext.class,0);
}
public Parameter_nameContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_parameter_name; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterParameter_name(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitParameter_name(this);
}
}
@RuleVersion(0)
public final Parameter_nameContext parameter_name() throws RecognitionException {
Parameter_nameContext _localctx = new Parameter_nameContext(_ctx, getState());
enterRule(_localctx, 166, RULE_parameter_name);
try {
enterOuterAlt(_localctx, 1);
{
setState(850); identifier();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Param_type_listContext extends ParserRuleContext {
public List<? extends Param_typeContext> param_type() {
return getRuleContexts(Param_typeContext.class);
}
public TerminalNode VOID() { return getToken(ModuleParser.VOID, 0); }
public Param_typeContext param_type(int i) {
return getRuleContext(Param_typeContext.class,i);
}
public Param_type_listContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_param_type_list; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterParam_type_list(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitParam_type_list(this);
}
}
@RuleVersion(0)
public final Param_type_listContext param_type_list() throws RecognitionException {
Param_type_listContext _localctx = new Param_type_listContext(_ctx, getState());
enterRule(_localctx, 168, RULE_param_type_list);
int _la;
try {
setState(867);
switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) {
case 1:
enterOuterAlt(_localctx, 1);
{
setState(852); match(30);
setState(853); match(VOID);
setState(854); match(12);
}
break;
case 2:
enterOuterAlt(_localctx, 2);
{
setState(855); match(30);
setState(864);
_la = _input.LA(1);
if (((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (VOID - 69)) | (1L << (UNSIGNED - 69)) | (1L << (SIGNED - 69)) | (1L << (LONG - 69)) | (1L << (CV_QUALIFIER - 69)) | (1L << (AUTO - 69)) | (1L << (REGISTER - 69)) | (1L << (CLASS_KEY - 69)) | (1L << (ALPHA_NUMERIC - 69)))) != 0)) {
{
setState(856); param_type();
setState(861);
_errHandler.sync(this);
_la = _input.LA(1);
while (_la==27) {
{
{
setState(857); match(27);
setState(858); param_type();
}
}
setState(863);
_errHandler.sync(this);
_la = _input.LA(1);
}
}
}
setState(866); match(12);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Param_typeContext extends ParserRuleContext {
public Param_type_idContext param_type_id() {
return getRuleContext(Param_type_idContext.class,0);
}
public Param_decl_specifiersContext param_decl_specifiers() {
return getRuleContext(Param_decl_specifiersContext.class,0);
}
public Param_typeContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_param_type; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterParam_type(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitParam_type(this);
}
}
@RuleVersion(0)
public final Param_typeContext param_type() throws RecognitionException {
Param_typeContext _localctx = new Param_typeContext(_ctx, getState());
enterRule(_localctx, 170, RULE_param_type);
try {
enterOuterAlt(_localctx, 1);
{
setState(869); param_decl_specifiers();
setState(870); param_type_id();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class Param_type_idContext extends ParserRuleContext {
public PtrsContext ptrs() {
return getRuleContext(PtrsContext.class,0);
}
public Param_type_idContext param_type_id() {
return getRuleContext(Param_type_idContext.class,0);
}
public Parameter_nameContext parameter_name() {
return getRuleContext(Parameter_nameContext.class,0);
}
public Type_suffixContext type_suffix() {
return getRuleContext(Type_suffixContext.class,0);
}
public Param_type_idContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_param_type_id; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterParam_type_id(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitParam_type_id(this);
}
}
@RuleVersion(0)
public final Param_type_idContext param_type_id() throws RecognitionException {
Param_type_idContext _localctx = new Param_type_idContext(_ctx, getState());
enterRule(_localctx, 172, RULE_param_type_id);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(873);
_la = _input.LA(1);
if (_la==1 || _la==2) {
{
setState(872); ptrs();
}
}
setState(882);
switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) {
case 1:
{
setState(875); match(30);
setState(876); param_type_id();
setState(877); match(12);
}
break;
case 2:
{
setState(880);
_la = _input.LA(1);
if (((((_la - 26)) & ~0x3f) == 0 && ((1L << (_la - 26)) & ((1L << (26 - 26)) | (1L << (32 - 26)) | (1L << (46 - 26)) | (1L << (ALPHA_NUMERIC - 26)))) != 0)) {
{
setState(879); parameter_name();
}
}
}
break;
}
setState(885);
_la = _input.LA(1);
if (_la==3 || _la==30) {
{
setState(884); type_suffix();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class IdentifierContext extends ParserRuleContext {
public List<? extends TerminalNode> ALPHA_NUMERIC() { return getTokens(ModuleParser.ALPHA_NUMERIC); }
public Access_specifierContext access_specifier() {
return getRuleContext(Access_specifierContext.class,0);
}
public TerminalNode ALPHA_NUMERIC(int i) {
return getToken(ModuleParser.ALPHA_NUMERIC, i);
}
public IdentifierContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_identifier; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterIdentifier(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitIdentifier(this);
}
}
@RuleVersion(0)
public final IdentifierContext identifier() throws RecognitionException {
IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
enterRule(_localctx, 174, RULE_identifier);
try {
int _alt;
setState(896);
switch (_input.LA(1)) {
case ALPHA_NUMERIC:
enterOuterAlt(_localctx, 1);
{
{
setState(887); match(ALPHA_NUMERIC);
setState(892);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,101,_ctx);
while ( _alt!=2 && _alt!=-1 ) {
if ( _alt==1 ) {
{
{
setState(888); match(15);
setState(889); match(ALPHA_NUMERIC);
}
}
}
setState(894);
_errHandler.sync(this);
_alt = getInterpreter().adaptivePredict(_input,101,_ctx);
}
}
}
break;
case 26:
case 32:
case 46:
enterOuterAlt(_localctx, 2);
{
setState(895); access_specifier();
}
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 NumberContext extends ParserRuleContext {
public TerminalNode OCTAL_LITERAL() { return getToken(ModuleParser.OCTAL_LITERAL, 0); }
public TerminalNode DECIMAL_LITERAL() { return getToken(ModuleParser.DECIMAL_LITERAL, 0); }
public TerminalNode HEX_LITERAL() { return getToken(ModuleParser.HEX_LITERAL, 0); }
public NumberContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_number; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterNumber(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitNumber(this);
}
}
@RuleVersion(0)
public final NumberContext number() throws RecognitionException {
NumberContext _localctx = new NumberContext(_ctx, getState());
enterRule(_localctx, 176, RULE_number);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(898);
_la = _input.LA(1);
if ( !(((((_la - 92)) & ~0x3f) == 0 && ((1L << (_la - 92)) & ((1L << (HEX_LITERAL - 92)) | (1L << (DECIMAL_LITERAL - 92)) | (1L << (OCTAL_LITERAL - 92)))) != 0)) ) {
_errHandler.recoverInline(this);
}
consume();
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.reportError(this, re);
_errHandler.recover(this, re);
}
finally {
exitRule();
}
return _localctx;
}
public static class PtrsContext extends ParserRuleContext {
public List<? extends Ptr_operatorContext> ptr_operator() {
return getRuleContexts(Ptr_operatorContext.class);
}
public Ptr_operatorContext ptr_operator(int i) {
return getRuleContext(Ptr_operatorContext.class,i);
}
public PtrsContext(ParserRuleContext parent, int invokingState) {
super(parent, invokingState);
}
@Override public int getRuleIndex() { return RULE_ptrs; }
@Override
public void enterRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).enterPtrs(this);
}
@Override
public void exitRule(ParseTreeListener listener) {
if ( listener instanceof ModuleListener ) ((ModuleListener)listener).exitPtrs(this);
}
}
@RuleVersion(0)
public final PtrsContext ptrs() throws RecognitionException {
PtrsContext _localctx = new PtrsContext(_ctx, getState());
enterRule(_localctx, 178, RULE_ptrs);
int _la;
try {
enterOuterAlt(_localctx, 1);
{
setState(904);
_errHandler.sync(this);
_la = _input.LA(1);
do {
{
{
setState(900); ptr_operator();
setState(902);
_la = _input.LA(1);
if (_la==17) {
{
setState(901); match(17);
}
}
}
}
setState(906);
_errHandler.sync(this);
_la = _input.LA(1);
} while ( _la==1 || _la==2 );
}
}
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 25: return postfix_expression_sempred((Postfix_expressionContext)_localctx, predIndex);
}
return true;
}
private boolean postfix_expression_sempred(Postfix_expressionContext _localctx, int predIndex) {
switch (predIndex) {
case 0: return precpred(_ctx, 6);
case 1: return precpred(_ctx, 5);
case 2: return precpred(_ctx, 4);
case 3: return precpred(_ctx, 3);
case 4: return precpred(_ctx, 2);
}
return true;
}
public static final String _serializedATN =
"\3\uaf6f\u8320\u479d\ub75c\u4880\u1605\u191c\uab37\3g\u038f\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[\3\2\3\2\3\2\3\2\7\2\u00bb\n"+
"\2\f\2\16\2\u00be\13\2\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\5\4\u00c8\n\4\3"+
"\5\3\5\3\5\3\5\5\5\u00ce\n\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\5\6\u00d7\n\6"+
"\3\7\3\7\3\7\5\7\u00dc\n\7\3\b\3\b\3\b\5\b\u00e1\n\b\3\t\3\t\3\t\5\t\u00e6"+
"\n\t\3\n\3\n\3\n\5\n\u00eb\n\n\3\13\3\13\3\13\5\13\u00f0\n\13\3\f\3\f"+
"\3\f\3\f\5\f\u00f6\n\f\3\r\3\r\3\r\3\r\5\r\u00fc\n\r\3\16\3\16\3\16\5"+
"\16\u0101\n\16\3\17\3\17\3\17\5\17\u0106\n\17\3\20\3\20\3\20\5\20\u010b"+
"\n\20\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u0113\n\21\3\22\3\22\7\22\u0117"+
"\n\22\f\22\16\22\u011a\13\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u0123"+
"\n\23\3\24\5\24\u0126\n\24\3\24\3\24\3\24\3\24\5\24\u012c\n\24\3\24\3"+
"\24\3\24\5\24\u0131\n\24\3\24\3\24\3\24\3\24\5\24\u0137\n\24\3\24\3\24"+
"\5\24\u013b\n\24\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26"+
"\5\26\u0148\n\26\3\27\3\27\3\30\3\30\7\30\u014e\n\30\f\30\16\30\u0151"+
"\13\30\3\31\3\31\3\32\3\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33"+
"\3\33\3\33\3\33\3\33\3\33\3\33\3\33\5\33\u0167\n\33\3\33\3\33\3\33\3\33"+
"\5\33\u016d\n\33\3\33\3\33\3\33\7\33\u0172\n\33\f\33\16\33\u0175\13\33"+
"\3\34\3\34\3\34\7\34\u017a\n\34\f\34\16\34\u017d\13\34\5\34\u017f\n\34"+
"\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\5\36\u0189\n\36\3\37\3\37\3 "+
"\3 \3!\3!\3\"\3\"\3#\3#\3$\3$\3%\3%\3%\5%\u019a\n%\3%\3%\3%\3%\3%\3%\3"+
"%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3"+
"%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\5%\u01c4\n%\3&\3&\3\'\3\'\3(\3(\3(\3("+
"\3(\3)\3)\3)\3)\3)\3)\3)\3)\3)\6)\u01d8\n)\r)\16)\u01d9\3*\3*\3+\3+\3"+
",\3,\3-\3-\3.\3.\3/\3/\3\60\3\60\3\61\3\61\3\62\3\62\3\63\3\63\3\64\3"+
"\64\3\65\5\65\u01f3\n\65\3\65\5\65\u01f6\n\65\3\65\3\65\3\65\5\65\u01fb"+
"\n\65\3\65\3\65\3\66\7\66\u0200\n\66\f\66\16\66\u0203\13\66\3\66\3\66"+
"\3\66\7\66\u0208\n\66\f\66\16\66\u020b\13\66\3\67\3\67\5\67\u020f\n\67"+
"\3\67\3\67\7\67\u0213\n\67\f\67\16\67\u0216\13\67\3\67\5\67\u0219\n\67"+
"\38\38\38\78\u021e\n8\f8\168\u0221\138\38\38\58\u0225\n8\38\58\u0228\n"+
"8\39\39\39\3:\5:\u022e\n:\3:\3:\3:\3:\3:\5:\u0235\n:\3:\5:\u0238\n:\3"+
";\3;\3;\3<\3<\3<\3<\7<\u0241\n<\f<\16<\u0244\13<\3=\3=\3=\3>\5>\u024a"+
"\n>\3>\3>\3?\3?\5?\u0250\n?\3?\3?\3@\3@\3@\3@\3@\3@\3@\5@\u025b\n@\3A"+
"\3A\3A\3A\3A\3B\7B\u0263\nB\fB\16B\u0266\13B\3B\3B\3B\3B\7B\u026c\nB\f"+
"B\16B\u026f\13B\7B\u0271\nB\fB\16B\u0274\13B\3C\3C\3C\5C\u0279\nC\3C\3"+
"C\3C\5C\u027e\nC\3D\5D\u0281\nD\3D\3D\5D\u0285\nD\3E\3E\3E\3E\3E\5E\u028c"+
"\nE\3F\7F\u028f\nF\fF\16F\u0292\13F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3"+
"F\5F\u02a0\nF\3F\7F\u02a3\nF\fF\16F\u02a6\13F\7F\u02a8\nF\fF\16F\u02ab"+
"\13F\3G\7G\u02ae\nG\fG\16G\u02b1\13G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G"+
"\3G\5G\u02bf\nG\3G\7G\u02c2\nG\fG\16G\u02c5\13G\7G\u02c7\nG\fG\16G\u02ca"+
"\13G\3H\7H\u02cd\nH\fH\16H\u02d0\13H\3H\3H\3H\3H\7H\u02d6\nH\fH\16H\u02d9"+
"\13H\7H\u02db\nH\fH\16H\u02de\13H\3I\5I\u02e1\nI\3I\5I\u02e4\nI\3I\3I"+
"\3J\3J\5J\u02ea\nJ\3J\3J\3J\5J\u02ef\nJ\3K\3K\3K\7K\u02f4\nK\fK\16K\u02f7"+
"\13K\3K\3K\3L\3L\3L\3L\3L\5L\u0300\nL\3M\3M\3M\7M\u0305\nM\fM\16M\u0308"+
"\13M\3N\3N\5N\u030c\nN\3N\5N\u030f\nN\3N\3N\3N\3O\3O\3P\3P\3P\3P\7P\u031a"+
"\nP\fP\16P\u031d\13P\3Q\5Q\u0320\nQ\3Q\5Q\u0323\nQ\3Q\3Q\3R\7R\u0328\n"+
"R\fR\16R\u032b\13R\3R\5R\u032e\nR\3R\3R\3R\3R\3R\5R\u0335\nR\3R\3R\3R"+
"\3R\3R\3R\5R\u033d\nR\7R\u033f\nR\fR\16R\u0342\13R\3R\5R\u0345\nR\3R\3"+
"R\5R\u0349\nR\3S\6S\u034c\nS\rS\16S\u034d\3T\5T\u0351\nT\3T\3T\3U\3U\3"+
"V\3V\3V\3V\3V\3V\3V\7V\u035e\nV\fV\16V\u0361\13V\5V\u0363\nV\3V\5V\u0366"+
"\nV\3W\3W\3W\3X\5X\u036c\nX\3X\3X\3X\3X\3X\5X\u0373\nX\5X\u0375\nX\3X"+
"\5X\u0378\nX\3Y\3Y\3Y\7Y\u037d\nY\fY\16Y\u0380\13Y\3Y\5Y\u0383\nY\3Z\3"+
"Z\3[\3[\5[\u0389\n[\6[\u038b\n[\r[\16[\u038c\3[\2\2\3\64\\\2\2\4\2\6\2"+
"\b\2\n\2\f\2\16\2\20\2\22\2\24\2\26\2\30\2\32\2\34\2\36\2 \2\"\2$\2&\2"+
"(\2*\2,\2.\2\60\2\62\2\64\2\66\28\2:\2<\2>\2@\2B\2D\2F\2H\2J\2L\2N\2P"+
"\2R\2T\2V\2X\2Z\2\\\2^\2`\2b\2d\2f\2h\2j\2l\2n\2p\2r\2t\2v\2x\2z\2|\2"+
"~\2\u0080\2\u0082\2\u0084\2\u0086\2\u0088\2\u008a\2\u008c\2\u008e\2\u0090"+
"\2\u0092\2\u0094\2\u0096\2\u0098\2\u009a\2\u009c\2\u009e\2\u00a0\2\u00a2"+
"\2\u00a4\2\u00a6\2\u00a8\2\u00aa\2\u00ac\2\u00ae\2\u00b0\2\u00b2\2\u00b4"+
"\2\2\34\4\2\n\n++\4\2\36\36//\5\2\4\4\f\f\67\67\4\2\7\7**\7\2\3\4\26\26"+
"\36\36//99\6\2\6\6\t\t\64\64::\3\2^c\5\2\17\20()LL\3\2\3\4\5\2\34\34\""+
"\"\60\60\4\2,,VV\n\2\r\r\22\22\24\24\31\32!!$$&\'\65\66\4\2\b\b88\4\2"+
"\16\16 \7\2\5\5\16\16\30\30 YZ\5\2\16\16 \61\61\6\2\6\6\16\16 \64"+
"\64\3\2YZ\4\2\5\5\30\30\5\2\5\5\30\30\61\61\4\2\35\35\61\61\t\2\5\5\16"+
"\16\30\30\35\35 \61\61YZ\4\2HIWW\5\2GGJJXX\3\2RS\3\2^`\u03d1\2\u00bc"+
"\3\2\2\2\4\u00bf\3\2\2\2\6\u00c4\3\2\2\2\b\u00c9\3\2\2\2\n\u00d6\3\2\2"+
"\2\f\u00d8\3\2\2\2\16\u00dd\3\2\2\2\20\u00e2\3\2\2\2\22\u00e7\3\2\2\2"+
"\24\u00ec\3\2\2\2\26\u00f1\3\2\2\2\30\u00f7\3\2\2\2\32\u00fd\3\2\2\2\34"+
"\u0102\3\2\2\2\36\u0107\3\2\2\2 \u0112\3\2\2\2\"\u0114\3\2\2\2$\u0122"+
"\3\2\2\2&\u013a\3\2\2\2(\u013c\3\2\2\2*\u0147\3\2\2\2,\u0149\3\2\2\2."+
"\u014b\3\2\2\2\60\u0152\3\2\2\2\62\u0154\3\2\2\2\64\u0156\3\2\2\2\66\u017e"+
"\3\2\2\28\u0180\3\2\2\2:\u0188\3\2\2\2<\u018a\3\2\2\2>\u018c\3\2\2\2@"+
"\u018e\3\2\2\2B\u0190\3\2\2\2D\u0192\3\2\2\2F\u0194\3\2\2\2H\u01c3\3\2"+
"\2\2J\u01c5\3\2\2\2L\u01c7\3\2\2\2N\u01c9\3\2\2\2P\u01d7\3\2\2\2R\u01db"+
"\3\2\2\2T\u01dd\3\2\2\2V\u01df\3\2\2\2X\u01e1\3\2\2\2Z\u01e3\3\2\2\2\\"+
"\u01e5\3\2\2\2^\u01e7\3\2\2\2`\u01e9\3\2\2\2b\u01eb\3\2\2\2d\u01ed\3\2"+
"\2\2f\u01ef\3\2\2\2h\u01f2\3\2\2\2j\u0201\3\2\2\2l\u020c\3\2\2\2n\u0227"+
"\3\2\2\2p\u0229\3\2\2\2r\u022d\3\2\2\2t\u0239\3\2\2\2v\u023c\3\2\2\2x"+
"\u0245\3\2\2\2z\u0249\3\2\2\2|\u024d\3\2\2\2~\u025a\3\2\2\2\u0080\u025c"+
"\3\2\2\2\u0082\u0264\3\2\2\2\u0084\u0275\3\2\2\2\u0086\u0280\3\2\2\2\u0088"+
"\u028b\3\2\2\2\u008a\u0290\3\2\2\2\u008c\u02af\3\2\2\2\u008e\u02ce\3\2"+
"\2\2\u0090\u02e0\3\2\2\2\u0092\u02ee\3\2\2\2\u0094\u02f0\3\2\2\2\u0096"+
"\u02ff\3\2\2\2\u0098\u0301\3\2\2\2\u009a\u0309\3\2\2\2\u009c\u0313\3\2"+
"\2\2\u009e\u0315\3\2\2\2\u00a0\u031f\3\2\2\2\u00a2\u0348\3\2\2\2\u00a4"+
"\u034b\3\2\2\2\u00a6\u0350\3\2\2\2\u00a8\u0354\3\2\2\2\u00aa\u0365\3\2"+
"\2\2\u00ac\u0367\3\2\2\2\u00ae\u036b\3\2\2\2\u00b0\u0382\3\2\2\2\u00b2"+
"\u0384\3\2\2\2\u00b4\u038a\3\2\2\2\u00b6\u00bb\5h\65\2\u00b7\u00bb\5\u0090"+
"I\2\u00b8\u00bb\5\4\3\2\u00b9\u00bb\5f\64\2\u00ba\u00b6\3\2\2\2\u00ba"+
"\u00b7\3\2\2\2\u00ba\u00b8\3\2\2\2\u00ba\u00b9\3\2\2\2\u00bb\u00be\3\2"+
"\2\2\u00bc\u00ba\3\2\2\2\u00bc\u00bd\3\2\2\2\u00bd\3\3\2\2\2\u00be\u00bc"+
"\3\2\2\2\u00bf\u00c0\7P\2\2\u00c0\u00c1\7Q\2\2\u00c1\u00c2\5\u00b0Y\2"+
"\u00c2\u00c3\7\61\2\2\u00c3\5\3\2\2\2\u00c4\u00c7\5\b\5\2\u00c5\u00c6"+
"\7\35\2\2\u00c6\u00c8\5\6\4\2\u00c7\u00c5\3\2\2\2\u00c7\u00c8\3\2\2\2"+
"\u00c8\7\3\2\2\2\u00c9\u00cd\5\n\6\2\u00ca\u00cb\5J&\2\u00cb\u00cc\5\b"+
"\5\2\u00cc\u00ce\3\2\2\2\u00cd\u00ca\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce"+
"\t\3\2\2\2\u00cf\u00d7\5\f\7\2\u00d0\u00d1\5\f\7\2\u00d1\u00d2\7#\2\2"+
"\u00d2\u00d3\5\6\4\2\u00d3\u00d4\7\37\2\2\u00d4\u00d5\5\n\6\2\u00d5\u00d7"+
"\3\2\2\2\u00d6\u00cf\3\2\2\2\u00d6\u00d0\3\2\2\2\u00d7\13\3\2\2\2\u00d8"+
"\u00db\5\16\b\2\u00d9\u00da\7\63\2\2\u00da\u00dc\5\f\7\2\u00db\u00d9\3"+
"\2\2\2\u00db\u00dc\3\2\2\2\u00dc\r\3\2\2\2\u00dd\u00e0\5\20\t\2\u00de"+
"\u00df\7\62\2\2\u00df\u00e1\5\16\b\2\u00e0\u00de\3\2\2\2\u00e0\u00e1\3"+
"\2\2\2\u00e1\17\3\2\2\2\u00e2\u00e5\5\22\n\2\u00e3\u00e4\7\25\2\2\u00e4"+
"\u00e6\5\20\t\2\u00e5\u00e3\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6\21\3\2\2"+
"\2\u00e7\u00ea\5\24\13\2\u00e8\u00e9\7-\2\2\u00e9\u00eb\5\22\n\2\u00ea"+
"\u00e8\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb\23\3\2\2\2\u00ec\u00ef\5\26\f"+
"\2\u00ed\u00ee\7\3\2\2\u00ee\u00f0\5\24\13\2\u00ef\u00ed\3\2\2\2\u00ef"+
"\u00f0\3\2\2\2\u00f0\25\3\2\2\2\u00f1\u00f5\5\30\r\2\u00f2\u00f3\5L\'"+
"\2\u00f3\u00f4\5\26\f\2\u00f4\u00f6\3\2\2\2\u00f5\u00f2\3\2\2\2\u00f5"+
"\u00f6\3\2\2\2\u00f6\27\3\2\2\2\u00f7\u00fb\5\32\16\2\u00f8\u00f9\5> "+
"\2\u00f9\u00fa\5\30\r\2\u00fa\u00fc\3\2\2\2\u00fb\u00f8\3\2\2\2\u00fb"+
"\u00fc\3\2\2\2\u00fc\31\3\2\2\2\u00fd\u0100\5\34\17\2\u00fe\u00ff\t\2"+
"\2\2\u00ff\u0101\5\32\16\2\u0100\u00fe\3\2\2\2\u0100\u0101\3\2\2\2\u0101"+
"\33\3\2\2\2\u0102\u0105\5\36\20\2\u0103\u0104\t\3\2\2\u0104\u0106\5\34"+
"\17\2\u0105\u0103\3\2\2\2\u0105\u0106\3\2\2\2\u0106\35\3\2\2\2\u0107\u010a"+
"\5 \21\2\u0108\u0109\t\4\2\2\u0109\u010b\5\36\20\2\u010a\u0108\3\2\2\2"+
"\u010a\u010b\3\2\2\2\u010b\37\3\2\2\2\u010c\u010d\7 \2\2\u010d\u010e\5"+
"\"\22\2\u010e\u010f\7\16\2\2\u010f\u0110\5 \21\2\u0110\u0113\3\2\2\2\u0111"+
"\u0113\5$\23\2\u0112\u010c\3\2\2\2\u0112\u0111\3\2\2\2\u0113!\3\2\2\2"+
"\u0114\u0118\5\u00a2R\2\u0115\u0117\5D#\2\u0116\u0115\3\2\2\2\u0117\u011a"+
"\3\2\2\2\u0118\u0116\3\2\2\2\u0118\u0119\3\2\2\2\u0119#\3\2\2\2\u011a"+
"\u0118\3\2\2\2\u011b\u011c\5\62\32\2\u011c\u011d\5 \21\2\u011d\u0123\3"+
"\2\2\2\u011e\u0123\5(\25\2\u011f\u0123\5*\26\2\u0120\u0123\5&\24\2\u0121"+
"\u0123\5\64\33\2\u0122\u011b\3\2\2\2\u0122\u011e\3\2\2\2\u0122\u011f\3"+
"\2\2\2\u0122\u0120\3\2\2\2\u0122\u0121\3\2\2\2\u0123%\3\2\2\2\u0124\u0126"+
"\7\21\2\2\u0125\u0124\3\2\2\2\u0125\u0126\3\2\2\2\u0126\u0127\3\2\2\2"+
"\u0127\u0128\7V\2\2\u0128\u0129\5\u00a2R\2\u0129\u012b\7\5\2\2\u012a\u012c"+
"\5\n\6\2\u012b\u012a\3\2\2\2\u012b\u012c\3\2\2\2\u012c\u012d\3\2\2\2\u012d"+
"\u012e\7\30\2\2\u012e\u013b\3\2\2\2\u012f\u0131\7\21\2\2\u0130\u012f\3"+
"\2\2\2\u0130\u0131\3\2\2\2\u0131\u0132\3\2\2\2\u0132\u0133\7V\2\2\u0133"+
"\u0134\5\u00a2R\2\u0134\u0136\7 \2\2\u0135\u0137\5\6\4\2\u0136\u0135\3"+
"\2\2\2\u0136\u0137\3\2\2\2\u0137\u0138\3\2\2\2\u0138\u0139\7\16\2\2\u0139"+
"\u013b\3\2\2\2\u013a\u0125\3\2\2\2\u013a\u0130\3\2\2\2\u013b\'\3\2\2\2"+
"\u013c\u013d\5<\37\2\u013d\u013e\5 \21\2\u013e)\3\2\2\2\u013f\u0140\5"+
",\27\2\u0140\u0141\7 \2\2\u0141\u0142\5.\30\2\u0142\u0143\7\16\2\2\u0143"+
"\u0148\3\2\2\2\u0144\u0145\5,\27\2\u0145\u0146\5\60\31\2\u0146\u0148\3"+
"\2\2\2\u0147\u013f\3\2\2\2\u0147\u0144\3\2\2\2\u0148+\3\2\2\2\u0149\u014a"+
"\7\27\2\2\u014a-\3\2\2\2\u014b\u014f\5\u00a2R\2\u014c\u014e\5D#\2\u014d"+
"\u014c\3\2\2\2\u014e\u0151\3\2\2\2\u014f\u014d\3\2\2\2\u014f\u0150\3\2"+
"\2\2\u0150/\3\2\2\2\u0151\u014f\3\2\2\2\u0152\u0153\5$\23\2\u0153\61\3"+
"\2\2\2\u0154\u0155\t\5\2\2\u0155\63\3\2\2\2\u0156\u0157\b\33\1\2\u0157"+
"\u0158\5:\36\2\u0158\u0173\3\2\2\2\u0159\u015a\f\b\2\2\u015a\u015b\7\5"+
"\2\2\u015b\u015c\5\6\4\2\u015c\u015d\7\30\2\2\u015d\u0172\3\2\2\2\u015e"+
"\u015f\f\7\2\2\u015f\u0160\7 \2\2\u0160\u0161\5\66\34\2\u0161\u0162\7"+
"\16\2\2\u0162\u0172\3\2\2\2\u0163\u0164\f\6\2\2\u0164\u0166\7.\2\2\u0165"+
"\u0167\7U\2\2\u0166\u0165\3\2\2\2\u0166\u0167\3\2\2\2\u0167\u0168\3\2"+
"\2\2\u0168\u0172\5\u00b0Y\2\u0169\u016a\f\5\2\2\u016a\u016c\7\13\2\2\u016b"+
"\u016d\7U\2\2\u016c\u016b\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016e\3\2"+
"\2\2\u016e\u0172\5\u00b0Y\2\u016f\u0170\f\4\2\2\u0170\u0172\5\62\32\2"+
"\u0171\u0159\3\2\2\2\u0171\u015e\3\2\2\2\u0171\u0163\3\2\2\2\u0171\u0169"+
"\3\2\2\2\u0171\u016f\3\2\2\2\u0172\u0175\3\2\2\2\u0173\u0171\3\2\2\2\u0173"+
"\u0174\3\2\2\2\u0174\65\3\2\2\2\u0175\u0173\3\2\2\2\u0176\u017b\58\35"+
"\2\u0177\u0178\7\35\2\2\u0178\u017a\58\35\2\u0179\u0177\3\2\2\2\u017a"+
"\u017d\3\2\2\2\u017b\u0179\3\2\2\2\u017b\u017c\3\2\2\2\u017c\u017f\3\2"+
"\2\2\u017d\u017b\3\2\2\2\u017e\u0176\3\2\2\2\u017e\u017f\3\2\2\2\u017f"+
"\67\3\2\2\2\u0180\u0181\5\b\5\2\u01819\3\2\2\2\u0182\u0189\5\u00b0Y\2"+
"\u0183\u0189\5@!\2\u0184\u0185\7 \2\2\u0185\u0186\5\6\4\2\u0186\u0187"+
"\7\16\2\2\u0187\u0189\3\2\2\2\u0188\u0182\3\2\2\2\u0188\u0183\3\2\2\2"+
"\u0188\u0184\3\2\2\2\u0189;\3\2\2\2\u018a\u018b\t\6\2\2\u018b=\3\2\2\2"+
"\u018c\u018d\t\7\2\2\u018d?\3\2\2\2\u018e\u018f\t\b\2\2\u018fA\3\2\2\2"+
"\u0190\u0191\t\t\2\2\u0191C\3\2\2\2\u0192\u0193\t\n\2\2\u0193E\3\2\2\2"+
"\u0194\u0195\t\13\2\2\u0195G\3\2\2\2\u0196\u0199\t\f\2\2\u0197\u0198\7"+
"\5\2\2\u0198\u019a\7\30\2\2\u0199\u0197\3\2\2\2\u0199\u019a\3\2\2\2\u019a"+
"\u01c4\3\2\2\2\u019b\u01c4\7/\2\2\u019c\u01c4\7\36\2\2\u019d\u01c4\7\4"+
"\2\2\u019e\u01c4\7\67\2\2\u019f\u01c4\7\f\2\2\u01a0\u01c4\7-\2\2\u01a1"+
"\u01c4\7\3\2\2\u01a2\u01c4\7\25\2\2\u01a3\u01c4\79\2\2\u01a4\u01c4\7\26"+
"\2\2\u01a5\u01c4\7\22\2\2\u01a6\u01c4\7\6\2\2\u01a7\u01c4\7\64\2\2\u01a8"+
"\u01c4\7&\2\2\u01a9\u01c4\7\32\2\2\u01aa\u01c4\7\r\2\2\u01ab\u01c4\7\66"+
"\2\2\u01ac\u01c4\7\65\2\2\u01ad\u01c4\7\'\2\2\u01ae\u01c4\7!\2\2\u01af"+
"\u01c4\7\24\2\2\u01b0\u01c4\7+\2\2\u01b1\u01c4\7\n\2\2\u01b2\u01c4\7$"+
"\2\2\u01b3\u01c4\7\31\2\2\u01b4\u01c4\78\2\2\u01b5\u01c4\7\b\2\2\u01b6"+
"\u01c4\7\t\2\2\u01b7\u01c4\7:\2\2\u01b8\u01c4\7\62\2\2\u01b9\u01c4\7\63"+
"\2\2\u01ba\u01c4\7*\2\2\u01bb\u01c4\7\7\2\2\u01bc\u01c4\7\35\2\2\u01bd"+
"\u01c4\7\33\2\2\u01be\u01c4\7\13\2\2\u01bf\u01c0\7 \2\2\u01c0\u01c4\7"+
"\16\2\2\u01c1\u01c2\7\5\2\2\u01c2\u01c4\7\30\2\2\u01c3\u0196\3\2\2\2\u01c3"+
"\u019b\3\2\2\2\u01c3\u019c\3\2\2\2\u01c3\u019d\3\2\2\2\u01c3\u019e\3\2"+
"\2\2\u01c3\u019f\3\2\2\2\u01c3\u01a0\3\2\2\2\u01c3\u01a1\3\2\2\2\u01c3"+
"\u01a2\3\2\2\2\u01c3\u01a3\3\2\2\2\u01c3\u01a4\3\2\2\2\u01c3\u01a5\3\2"+
"\2\2\u01c3\u01a6\3\2\2\2\u01c3\u01a7\3\2\2\2\u01c3\u01a8\3\2\2\2\u01c3"+
"\u01a9\3\2\2\2\u01c3\u01aa\3\2\2\2\u01c3\u01ab\3\2\2\2\u01c3\u01ac\3\2"+
"\2\2\u01c3\u01ad\3\2\2\2\u01c3\u01ae\3\2\2\2\u01c3\u01af\3\2\2\2\u01c3"+
"\u01b0\3\2\2\2\u01c3\u01b1\3\2\2\2\u01c3\u01b2\3\2\2\2\u01c3\u01b3\3\2"+
"\2\2\u01c3\u01b4\3\2\2\2\u01c3\u01b5\3\2\2\2\u01c3\u01b6\3\2\2\2\u01c3"+
"\u01b7\3\2\2\2\u01c3\u01b8\3\2\2\2\u01c3\u01b9\3\2\2\2\u01c3\u01ba\3\2"+
"\2\2\u01c3\u01bb\3\2\2\2\u01c3\u01bc\3\2\2\2\u01c3\u01bd\3\2\2\2\u01c3"+
"\u01be\3\2\2\2\u01c3\u01bf\3\2\2\2\u01c3\u01c1\3\2\2\2\u01c4I\3\2\2\2"+
"\u01c5\u01c6\t\r\2\2\u01c6K\3\2\2\2\u01c7\u01c8\t\16\2\2\u01c8M\3\2\2"+
"\2\u01c9\u01ca\7U\2\2\u01ca\u01cb\7\6\2\2\u01cb\u01cc\5P)\2\u01cc\u01cd"+
"\7\64\2\2\u01cdO\3\2\2\2\u01ce\u01cf\7\6\2\2\u01cf\u01d0\5P)\2\u01d0\u01d1"+
"\7\64\2\2\u01d1\u01d8\3\2\2\2\u01d2\u01d3\7 \2\2\u01d3\u01d4\5P)\2\u01d4"+
"\u01d5\7\16\2\2\u01d5\u01d8\3\2\2\2\u01d6\u01d8\5X-\2\u01d7\u01ce\3\2"+
"\2\2\u01d7\u01d2\3\2\2\2\u01d7\u01d6\3\2\2\2\u01d8\u01d9\3\2\2\2\u01d9"+
"\u01d7\3\2\2\2\u01d9\u01da\3\2\2\2\u01daQ\3\2\2\2\u01db\u01dc\n\17\2\2"+
"\u01dcS\3\2\2\2\u01dd\u01de\n\20\2\2\u01deU\3\2\2\2\u01df\u01e0\n\21\2"+
"\2\u01e0W\3\2\2\2\u01e1\u01e2\n\22\2\2\u01e2Y\3\2\2\2\u01e3\u01e4\n\23"+
"\2\2\u01e4[\3\2\2\2\u01e5\u01e6\n\24\2\2\u01e6]\3\2\2\2\u01e7\u01e8\n"+
"\25\2\2\u01e8_\3\2\2\2\u01e9\u01ea\n\26\2\2\u01eaa\3\2\2\2\u01eb\u01ec"+
"\n\27\2\2\u01ecc\3\2\2\2\u01ed\u01ee\n\20\2\2\u01eee\3\2\2\2\u01ef\u01f0"+
"\13\2\2\2\u01f0g\3\2\2\2\u01f1\u01f3\5N(\2\u01f2\u01f1\3\2\2\2\u01f2\u01f3"+
"\3\2\2\2\u01f3\u01f5\3\2\2\2\u01f4\u01f6\5j\66\2\u01f5\u01f4\3\2\2\2\u01f5"+
"\u01f6\3\2\2\2\u01f6\u01f7\3\2\2\2\u01f7\u01f8\5~@\2\u01f8\u01fa\5l\67"+
"\2\u01f9\u01fb\5v<\2\u01fa\u01f9\3\2\2\2\u01fa\u01fb\3\2\2\2\u01fb\u01fc"+
"\3\2\2\2\u01fc\u01fd\5t;\2\u01fdi\3\2\2\2\u01fe\u0200\5B\"\2\u01ff\u01fe"+
"\3\2\2\2\u0200\u0203\3\2\2\2\u0201\u01ff\3\2\2\2\u0201\u0202\3\2\2\2\u0202"+
"\u0204\3\2\2\2\u0203\u0201\3\2\2\2\u0204\u0205\5\u00a2R\2\u0205\u0209"+
"\3\2\2\2\u0206\u0208\5D#\2\u0207\u0206\3\2\2\2\u0208\u020b\3\2\2\2\u0209"+
"\u0207\3\2\2\2\u0209\u020a\3\2\2\2\u020ak\3\2\2\2\u020b\u0209\3\2\2\2"+
"\u020c\u020e\7 \2\2\u020d\u020f\5n8\2\u020e\u020d\3\2\2\2\u020e\u020f"+
"\3\2\2\2\u020f\u0210\3\2\2\2\u0210\u0214\7\16\2\2\u0211\u0213\7K\2\2\u0212"+
"\u0211\3\2\2\2\u0213\u0216\3\2\2\2\u0214\u0212\3\2\2\2\u0214\u0215\3\2"+
"\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2\2\2\u0217\u0219\5\u0080A\2\u0218"+
"\u0217\3\2\2\2\u0218\u0219\3\2\2\2\u0219m\3\2\2\2\u021a\u021f\5p9\2\u021b"+
"\u021c\7\35\2\2\u021c\u021e\5p9\2\u021d\u021b\3\2\2\2\u021e\u0221\3\2"+
"\2\2\u021f\u021d\3\2\2\2\u021f\u0220\3\2\2\2\u0220\u0224\3\2\2\2\u0221"+
"\u021f\3\2\2\2\u0222\u0223\7\35\2\2\u0223\u0225\7%\2\2\u0224\u0222\3\2"+
"\2\2\u0224\u0225\3\2\2\2\u0225\u0228\3\2\2\2\u0226\u0228\7G\2\2\u0227"+
"\u021a\3\2\2\2\u0227\u0226\3\2\2\2\u0228o\3\2\2\2\u0229\u022a\5\u00a6"+
"T\2\u022a\u022b\5r:\2\u022bq\3\2\2\2\u022c\u022e\5\u00b4[\2\u022d\u022c"+
"\3\2\2\2\u022d\u022e\3\2\2\2\u022e\u0234\3\2\2\2\u022f\u0230\7 \2\2\u0230"+
"\u0231\5r:\2\u0231\u0232\7\16\2\2\u0232\u0235\3\2\2\2\u0233\u0235\5\u00a8"+
"U\2\u0234\u022f\3\2\2\2\u0234\u0233\3\2\2\2\u0235\u0237\3\2\2\2\u0236"+
"\u0238\5\u0088E\2\u0237\u0236\3\2\2\2\u0237\u0238\3\2\2\2\u0238s\3\2\2"+
"\2\u0239\u023a\7Y\2\2\u023a\u023b\b;\1\2\u023bu\3\2\2\2\u023c\u023d\7"+
"\37\2\2\u023d\u0242\5x=\2\u023e\u023f\7\35\2\2\u023f\u0241\5x=\2\u0240"+
"\u023e\3\2\2\2\u0241\u0244\3\2\2\2\u0242\u0240\3\2\2\2\u0242\u0243\3\2"+
"\2\2\u0243w\3\2\2\2\u0244\u0242\3\2\2\2\u0245\u0246\5z>\2\u0246\u0247"+
"\5|?\2\u0247y\3\2\2\2\u0248\u024a\7\21\2\2\u0249\u0248\3\2\2\2\u0249\u024a"+
"\3\2\2\2\u024a\u024b\3\2\2\2\u024b\u024c\5\u00b0Y\2\u024c{\3\2\2\2\u024d"+
"\u024f\7 \2\2\u024e\u0250\5\6\4\2\u024f\u024e\3\2\2\2\u024f\u0250\3\2"+
"\2\2\u0250\u0251\3\2\2\2\u0251\u0252\7\16\2\2\u0252}\3\2\2\2\u0253\u0254"+
"\7 \2\2\u0254\u0255\5~@\2\u0255\u0256\7\16\2\2\u0256\u025b\3\2\2\2\u0257"+
"\u025b\5\u00b0Y\2\u0258\u0259\7T\2\2\u0259\u025b\5H%\2\u025a\u0253\3\2"+
"\2\2\u025a\u0257\3\2\2\2\u025a\u0258\3\2\2\2\u025b\177\3\2\2\2\u025c\u025d"+
"\7O\2\2\u025d\u025e\7 \2\2\u025e\u025f\5\u0082B\2\u025f\u0260\7\16\2\2"+
"\u0260\u0081\3\2\2\2\u0261\u0263\5R*\2\u0262\u0261\3\2\2\2\u0263\u0266"+
"\3\2\2\2\u0264\u0262\3\2\2\2\u0264\u0265\3\2\2\2\u0265\u0272\3\2\2\2\u0266"+
"\u0264\3\2\2\2\u0267\u0268\7 \2\2\u0268\u0269\5\u0082B\2\u0269\u026d\7"+
"\16\2\2\u026a\u026c\5R*\2\u026b\u026a\3\2\2\2\u026c\u026f\3\2\2\2\u026d"+
"\u026b\3\2\2\2\u026d\u026e\3\2\2\2\u026e\u0271\3\2\2\2\u026f\u026d\3\2"+
"\2\2\u0270\u0267\3\2\2\2\u0271\u0274\3\2\2\2\u0272\u0270\3\2\2\2\u0272"+
"\u0273\3\2\2\2\u0273\u0083\3\2\2\2\u0274\u0272\3\2\2\2\u0275\u027d\5\u0086"+
"D\2\u0276\u0278\7 \2\2\u0277\u0279\5\6\4\2\u0278\u0277\3\2\2\2\u0278\u0279"+
"\3\2\2\2\u0279\u027a\3\2\2\2\u027a\u027e\7\16\2\2\u027b\u027c\7\22\2\2"+
"\u027c\u027e\5\u008aF\2\u027d\u0276\3\2\2\2\u027d\u027b\3\2\2\2\u027d"+
"\u027e\3\2\2\2\u027e\u0085\3\2\2\2\u027f\u0281\5\u00b4[\2\u0280\u027f"+
"\3\2\2\2\u0280\u0281\3\2\2\2\u0281\u0282\3\2\2\2\u0282\u0284\5\u00b0Y"+
"\2\u0283\u0285\5\u0088E\2\u0284\u0283\3\2\2\2\u0284\u0285\3\2\2\2\u0285"+
"\u0087\3\2\2\2\u0286\u0287\7\5\2\2\u0287\u0288\5\u008eH\2\u0288\u0289"+
"\7\30\2\2\u0289\u028c\3\2\2\2\u028a\u028c\5\u00aaV\2\u028b\u0286\3\2\2"+
"\2\u028b\u028a\3\2\2\2\u028c\u0089\3\2\2\2\u028d\u028f\5b\62\2\u028e\u028d"+
"\3\2\2\2\u028f\u0292\3\2\2\2\u0290\u028e\3\2\2\2\u0290\u0291\3\2\2\2\u0291"+
"\u02a9\3\2\2\2\u0292\u0290\3\2\2\2\u0293\u0294\7Y\2\2\u0294\u0295\5\u008c"+
"G\2\u0295\u0296\7Z\2\2\u0296\u02a0\3\2\2\2\u0297\u0298\7 \2\2\u0298\u0299"+
"\5\u008cG\2\u0299\u029a\7\16\2\2\u029a\u02a0\3\2\2\2\u029b\u029c\7\5\2"+
"\2\u029c\u029d\5\u008cG\2\u029d\u029e\7\30\2\2\u029e\u02a0\3\2\2\2\u029f"+
"\u0293\3\2\2\2\u029f\u0297\3\2\2\2\u029f\u029b\3\2\2\2\u02a0\u02a4\3\2"+
"\2\2\u02a1\u02a3\5b\62\2\u02a2\u02a1\3\2\2\2\u02a3\u02a6\3\2\2\2\u02a4"+
"\u02a2\3\2\2\2\u02a4\u02a5\3\2\2\2\u02a5\u02a8\3\2\2\2\u02a6\u02a4\3\2"+
"\2\2\u02a7\u029f\3\2\2\2\u02a8\u02ab\3\2\2\2\u02a9\u02a7\3\2\2\2\u02a9"+
"\u02aa\3\2\2\2\u02aa\u008b\3\2\2\2\u02ab\u02a9\3\2\2\2\u02ac\u02ae\5d"+
"\63\2\u02ad\u02ac\3\2\2\2\u02ae\u02b1\3\2\2\2\u02af\u02ad\3\2\2\2\u02af"+
"\u02b0\3\2\2\2\u02b0\u02c8\3\2\2\2\u02b1\u02af\3\2\2\2\u02b2\u02b3\7Y"+
"\2\2\u02b3\u02b4\5\u008cG\2\u02b4\u02b5\7Z\2\2\u02b5\u02bf\3\2\2\2\u02b6"+
"\u02b7\7 \2\2\u02b7\u02b8\5\u008cG\2\u02b8\u02b9\7\16\2\2\u02b9\u02bf"+
"\3\2\2\2\u02ba\u02bb\7\5\2\2\u02bb\u02bc\5\u008cG\2\u02bc\u02bd\7\30\2"+
"\2\u02bd\u02bf\3\2\2\2\u02be\u02b2\3\2\2\2\u02be\u02b6\3\2\2\2\u02be\u02ba"+
"\3\2\2\2\u02bf\u02c3\3\2\2\2\u02c0\u02c2\5d\63\2\u02c1\u02c0\3\2\2\2\u02c2"+
"\u02c5\3\2\2\2\u02c3\u02c1\3\2\2\2\u02c3\u02c4\3\2\2\2\u02c4\u02c7\3\2"+
"\2\2\u02c5\u02c3\3\2\2\2\u02c6\u02be\3\2\2\2\u02c7\u02ca\3\2\2\2\u02c8"+
"\u02c6\3\2\2\2\u02c8\u02c9\3\2\2\2\u02c9\u008d\3\2\2\2\u02ca\u02c8\3\2"+
"\2\2\u02cb\u02cd\5\\/\2\u02cc\u02cb\3\2\2\2\u02cd\u02d0\3\2\2\2\u02ce"+
"\u02cc\3\2\2\2\u02ce\u02cf\3\2\2\2\u02cf\u02dc\3\2\2\2\u02d0\u02ce\3\2"+
"\2\2\u02d1\u02d2\7\5\2\2\u02d2\u02d3\5\u008eH\2\u02d3\u02d7\7\30\2\2\u02d4"+
"\u02d6\5\\/\2\u02d5\u02d4\3\2\2\2\u02d6\u02d9\3\2\2\2\u02d7\u02d5\3\2"+
"\2\2\u02d7\u02d8\3\2\2\2\u02d8\u02db\3\2\2\2\u02d9\u02d7\3\2\2\2\u02da"+
"\u02d1\3\2\2\2\u02db\u02de\3\2\2\2\u02dc\u02da\3\2\2\2\u02dc\u02dd\3\2"+
"\2\2\u02dd\u008f\3\2\2\2\u02de\u02dc\3\2\2\2\u02df\u02e1\7F\2\2\u02e0"+
"\u02df\3\2\2\2\u02e0\u02e1\3\2\2\2\u02e1\u02e3\3\2\2\2\u02e2\u02e4\5N"+
"(\2\u02e3\u02e2\3\2\2\2\u02e3\u02e4\3\2\2\2\u02e4\u02e5\3\2\2\2\u02e5"+
"\u02e6\5\u0092J\2\u02e6\u0091\3\2\2\2\u02e7\u02e9\5\u009aN\2\u02e8\u02ea"+
"\5\u0094K\2\u02e9\u02e8\3\2\2\2\u02e9\u02ea\3\2\2\2\u02ea\u02ef\3\2\2"+
"\2\u02eb\u02ec\5\u00a2R\2\u02ec\u02ed\5\u0094K\2\u02ed\u02ef\3\2\2\2\u02ee"+
"\u02e7\3\2\2\2\u02ee\u02eb\3\2\2\2\u02ef\u0093\3\2\2\2\u02f0\u02f5\5\u0084"+
"C\2\u02f1\u02f2\7\35\2\2\u02f2\u02f4\5\u0084C\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\u02f8\3\2"+
"\2\2\u02f7\u02f5\3\2\2\2\u02f8\u02f9\7\61\2\2\u02f9\u0095\3\2\2\2\u02fa"+
"\u0300\5\b\5\2\u02fb\u02fc\7Y\2\2\u02fc\u02fd\5\u0098M\2\u02fd\u02fe\7"+
"Z\2\2\u02fe\u0300\3\2\2\2\u02ff\u02fa\3\2\2\2\u02ff\u02fb\3\2\2\2\u0300"+
"\u0097\3\2\2\2\u0301\u0306\5\u0096L\2\u0302\u0303\7\35\2\2\u0303\u0305"+
"\5\u0096L\2\u0304\u0302\3\2\2\2\u0305\u0308\3\2\2\2\u0306\u0304\3\2\2"+
"\2\u0306\u0307\3\2\2\2\u0307\u0099\3\2\2\2\u0308\u0306\3\2\2\2\u0309\u030b"+
"\7W\2\2\u030a\u030c\5\u009cO\2\u030b\u030a\3\2\2\2\u030b\u030c\3\2\2\2"+
"\u030c\u030e\3\2\2\2\u030d\u030f\5\u009eP\2\u030e\u030d\3\2\2\2\u030e"+
"\u030f\3\2\2\2\u030f\u0310\3\2\2\2\u0310\u0311\7Y\2\2\u0311\u0312\bN\1"+
"\2\u0312\u009b\3\2\2\2\u0313\u0314\5\u00b0Y\2\u0314\u009d\3\2\2\2\u0315"+
"\u0316\7\37\2\2\u0316\u031b\5\u00a0Q\2\u0317\u0318\7\35\2\2\u0318\u031a"+
"\5\u00a0Q\2\u0319\u0317\3\2\2\2\u031a\u031d\3\2\2\2\u031b\u0319\3\2\2"+
"\2\u031b\u031c\3\2\2\2\u031c\u009f\3\2\2\2\u031d\u031b\3\2\2\2\u031e\u0320"+
"\7L\2\2\u031f\u031e\3\2\2\2\u031f\u0320\3\2\2\2\u0320\u0322\3\2\2\2\u0321"+
"\u0323\5F$\2\u0322\u0321\3\2\2\2\u0322\u0323\3\2\2\2\u0323\u0324\3\2\2"+
"\2\u0324\u0325\5\u00b0Y\2\u0325\u00a1\3\2\2\2\u0326\u0328\7K\2\2\u0327"+
"\u0326\3\2\2\2\u0328\u032b\3\2\2\2\u0329\u0327\3\2\2\2\u0329\u032a\3\2"+
"\2\2\u032a\u032d\3\2\2\2\u032b\u0329\3\2\2\2\u032c\u032e\t\30\2\2\u032d"+
"\u032c\3\2\2\2\u032d\u032e\3\2\2\2\u032e\u032f\3\2\2\2\u032f\u0334\5\u00a4"+
"S\2\u0330\u0331\7\6\2\2\u0331\u0332\5P)\2\u0332\u0333\7\64\2\2\u0333\u0335"+
"\3\2\2\2\u0334\u0330\3\2\2\2\u0334\u0335\3\2\2\2\u0335\u0340\3\2\2\2\u0336"+
"\u0337\7\21\2\2\u0337\u033c\5\u00a4S\2\u0338\u0339\7\6\2\2\u0339\u033a"+
"\5P)\2\u033a\u033b\7\64\2\2\u033b\u033d\3\2\2\2\u033c\u0338\3\2\2\2\u033c"+
"\u033d\3\2\2\2\u033d\u033f\3\2\2\2\u033e\u0336\3\2\2\2\u033f\u0342\3\2"+
"\2\2\u0340\u033e\3\2\2\2\u0340\u0341\3\2\2\2\u0341\u0344\3\2\2\2\u0342"+
"\u0340\3\2\2\2\u0343\u0345\7K\2\2\u0344\u0343\3\2\2\2\u0344\u0345\3\2"+
"\2\2\u0345\u0349\3\2\2\2\u0346\u0349\7H\2\2\u0347\u0349\7I\2\2\u0348\u0329"+
"\3\2\2\2\u0348\u0346\3\2\2\2\u0348\u0347\3\2\2\2\u0349\u00a3\3\2\2\2\u034a"+
"\u034c\t\31\2\2\u034b\u034a\3\2\2\2\u034c\u034d\3\2\2\2\u034d\u034b\3"+
"\2\2\2\u034d\u034e\3\2\2\2\u034e\u00a5\3\2\2\2\u034f\u0351\t\32\2\2\u0350"+
"\u034f\3\2\2\2\u0350\u0351\3\2\2\2\u0351\u0352\3\2\2\2\u0352\u0353\5\u00a2"+
"R\2\u0353\u00a7\3\2\2\2\u0354\u0355\5\u00b0Y\2\u0355\u00a9\3\2\2\2\u0356"+
"\u0357\7 \2\2\u0357\u0358\7G\2\2\u0358\u0366\7\16\2\2\u0359\u0362\7 \2"+
"\2\u035a\u035f\5\u00acW\2\u035b\u035c\7\35\2\2\u035c\u035e\5\u00acW\2"+
"\u035d\u035b\3\2\2\2\u035e\u0361\3\2\2\2\u035f\u035d\3\2\2\2\u035f\u0360"+
"\3\2\2\2\u0360\u0363\3\2\2\2\u0361\u035f\3\2\2\2\u0362\u035a\3\2\2\2\u0362"+
"\u0363\3\2\2\2\u0363\u0364\3\2\2\2\u0364\u0366\7\16\2\2\u0365\u0356\3"+
"\2\2\2\u0365\u0359\3\2\2\2\u0366\u00ab\3\2\2\2\u0367\u0368\5\u00a6T\2"+
"\u0368\u0369\5\u00aeX\2\u0369\u00ad\3\2\2\2\u036a\u036c\5\u00b4[\2\u036b"+
"\u036a\3\2\2\2\u036b\u036c\3\2\2\2\u036c\u0374\3\2\2\2\u036d\u036e\7 "+
"\2\2\u036e\u036f\5\u00aeX\2\u036f\u0370\7\16\2\2\u0370\u0375\3\2\2\2\u0371"+
"\u0373\5\u00a8U\2\u0372\u0371\3\2\2\2\u0372\u0373\3\2\2\2\u0373\u0375"+
"\3\2\2\2\u0374\u036d\3\2\2\2\u0374\u0372\3\2\2\2\u0375\u0377\3\2\2\2\u0376"+
"\u0378\5\u0088E\2\u0377\u0376\3\2\2\2\u0377\u0378\3\2\2\2\u0378\u00af"+
"\3\2\2\2\u0379\u037e\7X\2\2\u037a\u037b\7\21\2\2\u037b\u037d\7X\2\2\u037c"+
"\u037a\3\2\2\2\u037d\u0380\3\2\2\2\u037e\u037c\3\2\2\2\u037e\u037f\3\2"+
"\2\2\u037f\u0383\3\2\2\2\u0380\u037e\3\2\2\2\u0381\u0383\5F$\2\u0382\u0379"+
"\3\2\2\2\u0382\u0381\3\2\2\2\u0383\u00b1\3\2\2\2\u0384\u0385\t\33\2\2"+
"\u0385\u00b3\3\2\2\2\u0386\u0388\5D#\2\u0387\u0389\7\23\2\2\u0388\u0387"+
"\3\2\2\2\u0388\u0389\3\2\2\2\u0389\u038b\3\2\2\2\u038a\u0386\3\2\2\2\u038b"+
"\u038c\3\2\2\2\u038c\u038a\3\2\2\2\u038c\u038d\3\2\2\2\u038d\u00b5\3\2"+
"\2\2k\u00ba\u00bc\u00c7\u00cd\u00d6\u00db\u00e0\u00e5\u00ea\u00ef\u00f5"+
"\u00fb\u0100\u0105\u010a\u0112\u0118\u0122\u0125\u012b\u0130\u0136\u013a"+
"\u0147\u014f\u0166\u016c\u0171\u0173\u017b\u017e\u0188\u0199\u01c3\u01d7"+
"\u01d9\u01f2\u01f5\u01fa\u0201\u0209\u020e\u0214\u0218\u021f\u0224\u0227"+
"\u022d\u0234\u0237\u0242\u0249\u024f\u025a\u0264\u026d\u0272\u0278\u027d"+
"\u0280\u0284\u028b\u0290\u029f\u02a4\u02a9\u02af\u02be\u02c3\u02c8\u02ce"+
"\u02d7\u02dc\u02e0\u02e3\u02e9\u02ee\u02f5\u02ff\u0306\u030b\u030e\u031b"+
"\u031f\u0322\u0329\u032d\u0334\u033c\u0340\u0344\u0348\u034d\u0350\u035f"+
"\u0362\u0365\u036b\u0372\u0374\u0377\u037e\u0382\u0388\u038c";
public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static {
}
}