public StmtContext stmt()
{
StmtContext _localctx = new StmtContext(Context, State);
EnterRule(_localctx, 2, RULE_stmt);
try {
State = 42;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 1, Context))
{
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 40; def_stmt();
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 41; link_stmt();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public PowContext pow()
{
PowContext _localctx = new PowContext(Context, State);
EnterRule(_localctx, 8, RULE_pow);
try {
_localctx = new PowerContext(_localctx);
EnterOuterAlt(_localctx, 1);
{
State = 58; unaryMinus();
State = 61;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 6, Context))
{
case 1:
{
State = 59; Match(POW);
State = 60; pow();
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public ExpContext exp()
{
ExpContext _localctx = new ExpContext(Context, State);
EnterRule(_localctx, 8, RULE_exp);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 27;
ErrorHandler.Sync(this);
_la = TokenStream.La(1);
do
{
{
State = 27;
switch (Interpreter.AdaptivePredict(TokenStream, 0, Context))
{
case 1:
{
State = 23; block();
}
break;
case 2:
{
State = 24; token();
}
break;
case 3:
{
State = 25; opdef();
}
break;
case 4:
{
State = 26; Match(NEWLINE);
}
break;
}
}
State = 29;
ErrorHandler.Sync(this);
_la = TokenStream.La(1);
} while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__10) | (1L << T__11) | (1L << TRUE) | (1L << FALSE) | (1L << STRING) | (1L << INT) | (1L << FLOAT) | (1L << ID) | (1L << OP) | (1L << NATIVE) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK) | (1L << NEWLINE))) != 0));
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public DialogContext dialog()
{
DialogContext _localctx = new DialogContext(_ctx, State);
EnterRule(_localctx, 2, RULE_dialog);
try {
State = 24;
_errHandler.Sync(this);
switch (Interpreter.AdaptivePredict(_input, 1, _ctx))
{
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 22; messageDialog();
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 23; selectionDialog();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.ReportError(this, re);
_errHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public ImportDefinitionContext importDefinition()
{
ImportDefinitionContext _localctx = new ImportDefinitionContext(Context, State);
EnterRule(_localctx, 6, RULE_importDefinition);
try {
EnterOuterAlt(_localctx, 1);
{
State = 40; Match(IMPORT);
State = 42;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 3, Context))
{
case 1:
{
State = 41; Match(NEWLINE);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public CsvEndColContext csvEndCol()
{
CsvEndColContext _localctx = new CsvEndColContext(Context, State);
EnterRule(_localctx, 6, RULE_csvEndCol);
try {
EnterOuterAlt(_localctx, 1);
{
State = 30;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 3, Context))
{
case 1:
{
State = 29; _localctx.content = csvTxt();
}
break;
}
State = 32; Match(ROWEND);
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public OptionDefinitionContext optionDefinition()
{
OptionDefinitionContext _localctx = new OptionDefinitionContext(Context, State);
EnterRule(_localctx, 8, RULE_optionDefinition);
try {
EnterOuterAlt(_localctx, 1);
{
State = 44; Match(OPTION);
State = 46;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 4, Context))
{
case 1:
{
State = 45; Match(NEWLINE);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public ErrorDefinitionContext errorDefinition()
{
ErrorDefinitionContext _localctx = new ErrorDefinitionContext(Context, State);
EnterRule(_localctx, 10, RULE_errorDefinition);
try {
EnterOuterAlt(_localctx, 1);
{
State = 48; Match(INVALID_LINE);
State = 50;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 5, Context))
{
case 1:
{
State = 49; Match(NEWLINE);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public TemplateNameLineContext templateNameLine()
{
TemplateNameLineContext _localctx = new TemplateNameLineContext(Context, State);
EnterRule(_localctx, 14, RULE_templateNameLine);
try {
EnterOuterAlt(_localctx, 1);
{
State = 55; Match(TEMPLATE_NAME_LINE);
State = 57;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 6, Context))
{
case 1:
{
State = 56; Match(NEWLINE);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public CommentDefinitionContext commentDefinition()
{
CommentDefinitionContext _localctx = new CommentDefinitionContext(Context, State);
EnterRule(_localctx, 4, RULE_commentDefinition);
try {
EnterOuterAlt(_localctx, 1);
{
State = 36; Match(COMMENT);
State = 38;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 2, Context))
{
case 1:
{
State = 37; Match(NEWLINE);
}
break;
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public ItemContext item()
{
ItemContext _localctx = new ItemContext(_ctx, State);
EnterRule(_localctx, 2, RULE_item);
try {
State = 17;
switch (Interpreter.AdaptivePredict(_input, 1, _ctx))
{
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 15; range();
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 16; one();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.ReportError(this, re);
_errHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public FeatureContext feature() {
FeatureContext _localctx = new FeatureContext(Context, State);
EnterRule(_localctx, 4, RULE_feature);
try {
State = 46;
ErrorHandler.Sync(this);
switch ( Interpreter.AdaptivePredict(TokenStream,3,Context) ) {
case 1:
_localctx = new F_attrContext(_localctx);
EnterOuterAlt(_localctx, 1);
{
State = 44; attr();
}
break;
case 2:
_localctx = new F_methodContext(_localctx);
EnterOuterAlt(_localctx, 2);
{
State = 45; method();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return _localctx;
}
public Square_valueContext square_value()
{
Square_valueContext _localctx = new Square_valueContext(Context, State);
EnterRule(_localctx, 10, RULE_square_value);
try {
State = 53;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 4, Context))
{
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 51; square_value_without_spaces();
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 52; square_value_with_spaces();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public ExprContext expr()
{
ExprContext _localctx = new ExprContext(_ctx, State);
EnterRule(_localctx, 6, RULE_expr);
try {
EnterOuterAlt(_localctx, 1);
{
State = 65;
_errHandler.Sync(this);
switch (Interpreter.AdaptivePredict(_input, 1, _ctx))
{
case 1:
{
State = 46; checarEtiq();
State = 47; checarInstru();
State = 48; checarOp();
State = 49; Match(ENTER);
}
break;
case 2:
{
State = 51; checarEtiq();
State = 52; checarRsub();
State = 53; Match(ENTER);
}
break;
case 3:
{
State = 55; checarEtiq();
State = 56; checarDirec();
State = 57; checarOp();
State = 58; Match(ENTER);
}
break;
case 4:
{
State = 60; checarEtiq();
State = 61; checarByte();
State = 62; checarOpbyte();
State = 63; Match(ENTER);
}
break;
}
i++;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.ReportError(this, re);
_errHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public PseudoSelectorContext pseudoSelector()
{
PseudoSelectorContext _localctx = new PseudoSelectorContext(Context, State);
EnterRule(_localctx, 12, RULE_pseudoSelector);
try {
State = 100;
switch (Interpreter.AdaptivePredict(TokenStream, 15, Context))
{
case 1:
_localctx = new PseudoSelectorWithConstantContext(_localctx);
EnterOuterAlt(_localctx, 1);
{
State = 85; Match(COLON);
State = 86; Match(ID);
State = 91;
switch (Interpreter.AdaptivePredict(TokenStream, 13, Context))
{
case 1:
{
State = 87; Match(LEFT_BRACKET);
State = 88; constant();
State = 89; Match(RIGHT_BRACKET);
}
break;
}
}
break;
case 2:
_localctx = new PseudoSelectorWithIdentifierContext(_localctx);
EnterOuterAlt(_localctx, 2);
{
State = 93; Match(COLON);
State = 94; Match(ID);
State = 98;
switch (Interpreter.AdaptivePredict(TokenStream, 14, Context))
{
case 1:
{
State = 95; Match(LEFT_BRACKET);
State = 96; Match(ID);
State = 97; Match(RIGHT_BRACKET);
}
break;
}
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public ExprContext expr()
{
ExprContext _localctx = new ExprContext(Context, State);
EnterRule(_localctx, 14, RULE_expr);
try {
State = 74;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 4, Context))
{
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 72; term();
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 73; opExpression();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public FactorContext factor()
{
FactorContext _localctx = new FactorContext(Context, State);
EnterRule(_localctx, 6, RULE_factor);
try {
State = 46;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 5, Context))
{
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 44; Match(FACTOR);
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public LikePatternCharlistElementContext likePatternCharlistElement()
{
LikePatternCharlistElementContext _localctx = new LikePatternCharlistElementContext(_ctx, State);
EnterRule(_localctx, 10, RULE_likePatternCharlistElement);
try {
State = 54;
switch (Interpreter.AdaptivePredict(_input, 6, _ctx))
{
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 52; likePatternCharlistChar();
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 53; likePatternCharlistRange();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.ReportError(this, re);
_errHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public PropositionContext proposition()
{
PropositionContext _localctx = new PropositionContext(_ctx, State);
EnterRule(_localctx, 10, RULE_proposition);
try {
State = 60;
_errHandler.Sync(this);
switch (Interpreter.AdaptivePredict(_input, 5, _ctx))
{
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 58; instruction();
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 59; directive();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.ReportError(this, re);
_errHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public ChecarOpContext checarOp()
{
ChecarOpContext _localctx = new ChecarOpContext(_ctx, State);
EnterRule(_localctx, 14, RULE_checarOp);
int _la;
try {
State = 87;
_errHandler.Sync(this);
switch (Interpreter.AdaptivePredict(_input, 5, _ctx))
{
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 84;
_la = _input.La(1);
if (_la <= 0 || (_la == OPERANDO))
{
_errHandler.RecoverInline(this);
}
else
{
if (_input.La(1) == TokenConstants.Eof)
{
matchedEOF = true;
}
_errHandler.ReportMatch(this);
Consume();
}
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 85; Match(OPERANDO);
}
break;
case 3:
EnterOuterAlt(_localctx, 3);
{
State = 86; checarEtiq();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.ReportError(this, re);
_errHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public CondContext cond()
{
CondContext _localctx = new CondContext(Context, State);
EnterRule(_localctx, 10, RULE_cond);
try {
State = 56;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 2, Context))
{
case 1:
_localctx = new CondNoElseContext(_localctx);
EnterOuterAlt(_localctx, 1);
{
State = 42;
Match(IF);
State = 43;
Match(LP);
State = 44;
expr();
State = 45;
Match(RP);
State = 46;
braceblock();
}
break;
case 2:
_localctx = new CondElseContext(_localctx);
EnterOuterAlt(_localctx, 2);
{
State = 48;
Match(IF);
State = 49;
Match(LP);
State = 50;
expr();
State = 51;
Match(RP);
State = 52;
braceblock();
State = 53;
Match(ELSE);
State = 54;
braceblock();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
private PropositionsContext propositions(int _p)
{
ParserRuleContext _parentctx = _ctx;
int _parentState = State;
PropositionsContext _localctx = new PropositionsContext(_ctx, _parentState);
PropositionsContext _prevctx = _localctx;
int _startState = 8;
EnterRecursionRule(_localctx, 8, RULE_propositions, _p);
try {
int _alt;
EnterOuterAlt(_localctx, 1);
{
{
State = 49; proposition();
}
_ctx.stop = _input.Lt(-1);
State = 55;
_errHandler.Sync(this);
_alt = Interpreter.AdaptivePredict(_input, 4, _ctx);
while (_alt != 2 && _alt != global::Antlr4.Runtime.Atn.ATN.InvalidAltNumber)
{
if (_alt == 1)
{
if (_parseListeners != null)
{
TriggerExitRuleEvent();
}
_prevctx = _localctx;
{
{
_localctx = new PropositionsContext(_parentctx, _parentState);
PushNewRecursionContext(_localctx, _startState, RULE_propositions);
State = 51;
if (!(Precpred(_ctx, 2)))
{
throw new FailedPredicateException(this, "Precpred(_ctx, 2)");
}
State = 52; proposition();
}
}
}
State = 57;
_errHandler.Sync(this);
_alt = Interpreter.AdaptivePredict(_input, 4, _ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.ReportError(this, re);
_errHandler.Recover(this, re);
}
finally {
UnrollRecursionContexts(_parentctx);
}
return(_localctx);
}
public BodyContext body()
{
BodyContext _localctx = new BodyContext(Context, State);
EnterRule(_localctx, 2, RULE_body);
int _la;
try {
EnterOuterAlt(_localctx, 1);
{
State = 23;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 0, Context))
{
case 1:
{
State = 21; query_seq();
}
break;
case 2:
{
State = 22; restrictions();
}
break;
}
State = 26;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if (_la == T__0)
{
{
State = 25; Match(T__0);
}
}
State = 30;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
if (_la == InWin)
{
{
State = 28; Match(InWin);
State = 29; number();
}
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public StmtContext stmt()
{
StmtContext _localctx = new StmtContext(Context, State);
EnterRule(_localctx, 4, RULE_stmt);
try {
State = 56;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 4, Context))
{
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 48; node_stmt();
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 49; edge_stmt();
}
break;
case 3:
EnterOuterAlt(_localctx, 3);
{
State = 50; attr_stmt();
}
break;
case 4:
EnterOuterAlt(_localctx, 4);
{
State = 51; id();
State = 52; Match(T__3);
State = 53; id();
}
break;
case 5:
EnterOuterAlt(_localctx, 5);
{
State = 55; subgraph();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public ContentContext content()
{
ContentContext _localctx = new ContentContext(_ctx, State);
EnterRule(_localctx, 2, RULE_content);
int _la;
try {
int _alt;
EnterOuterAlt(_localctx, 1);
{
State = 17;
_la = _input.La(1);
if (_la == SEA_WS || _la == TEXT)
{
{
State = 16; chardata();
}
}
State = 25;
_errHandler.Sync(this);
_alt = Interpreter.AdaptivePredict(_input, 2, _ctx);
while (_alt != 2 && _alt != -1)
{
if (_alt == 1)
{
{
{
State = 19; element();
State = 21;
_la = _input.La(1);
if (_la == SEA_WS || _la == TEXT)
{
{
State = 20; chardata();
}
}
}
}
}
State = 27;
_errHandler.Sync(this);
_alt = Interpreter.AdaptivePredict(_input, 2, _ctx);
}
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.ReportError(this, re);
_errHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public FunctionContext function()
{
FunctionContext _localctx = new FunctionContext(Context, State);
EnterRule(_localctx, 4, RULE_function);
int _la;
try {
State = 70;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 4, Context))
{
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 56; Match(IDENTIFIER);
State = 57; Match(T__17);
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 58; Match(IDENTIFIER);
State = 59; Match(T__2);
State = 60; expr(0);
State = 65;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
while (_la == T__16)
{
{
{
State = 61; Match(T__16);
State = 62; expr(0);
}
}
State = 67;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
}
State = 68; Match(T__3);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public IndicadorContext indicador()
{
IndicadorContext _localctx = new IndicadorContext(_ctx, State);
EnterRule(_localctx, 0, RULE_indicador);
int _la;
try {
State = 15;
_errHandler.Sync(this);
switch (Interpreter.AdaptivePredict(_input, 0, _ctx))
{
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 10; producto();
{
State = 11;
_la = _input.La(1);
if (!(_la == T__0 || _la == T__1))
{
_errHandler.RecoverInline(this);
}
else
{
if (_input.La(1) == TokenConstants.Eof)
{
matchedEOF = true;
}
_errHandler.ReportMatch(this);
Consume();
}
State = 12; indicador();
}
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 14; producto();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.ReportError(this, re);
_errHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public ProductoContext producto()
{
ProductoContext _localctx = new ProductoContext(_ctx, State);
EnterRule(_localctx, 2, RULE_producto);
int _la;
try {
State = 22;
_errHandler.Sync(this);
switch (Interpreter.AdaptivePredict(_input, 1, _ctx))
{
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 17; factor();
{
State = 18;
_la = _input.La(1);
if (!(_la == T__2 || _la == T__3))
{
_errHandler.RecoverInline(this);
}
else
{
if (_input.La(1) == TokenConstants.Eof)
{
matchedEOF = true;
}
_errHandler.ReportMatch(this);
Consume();
}
State = 19; producto();
}
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 21; factor();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
_errHandler.ReportError(this, re);
_errHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public SignedAtomContext signedAtom()
{
SignedAtomContext _localctx = new SignedAtomContext(Context, State);
EnterRule(_localctx, 8, RULE_signedAtom);
try {
State = 51;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 3, Context))
{
case 1:
_localctx = new PlusAtomContext(_localctx);
EnterOuterAlt(_localctx, 1);
{
State = 45; Match(PLUS);
State = 46; atom();
}
break;
case 2:
_localctx = new NegativeAtomContext(_localctx);
EnterOuterAlt(_localctx, 2);
{
State = 47; Match(MINUS);
State = 48; atom();
}
break;
case 3:
_localctx = new FunctionContext(_localctx);
EnterOuterAlt(_localctx, 3);
{
State = 49; func();
}
break;
case 4:
_localctx = new UnsignedAtomContext(_localctx);
EnterOuterAlt(_localctx, 4);
{
State = 50; atom();
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
public OBjEcTContext oBjEcT()
{
OBjEcTContext _localctx = new OBjEcTContext(Context, State);
EnterRule(_localctx, 4, RULE_oBjEcT);
int _la;
try {
State = 40;
ErrorHandler.Sync(this);
switch (Interpreter.AdaptivePredict(TokenStream, 3, Context))
{
case 1:
EnterOuterAlt(_localctx, 1);
{
State = 27; Match(T__3);
State = 28; pair();
State = 33;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
while (_la == T__1)
{
{
{
State = 29; Match(T__1);
State = 30; pair();
}
}
State = 35;
ErrorHandler.Sync(this);
_la = TokenStream.LA(1);
}
State = 36; Match(T__4);
}
break;
case 2:
EnterOuterAlt(_localctx, 2);
{
State = 38; Match(T__3);
State = 39; Match(T__4);
}
break;
}
}
catch (RecognitionException re) {
_localctx.exception = re;
ErrorHandler.ReportError(this, re);
ErrorHandler.Recover(this, re);
}
finally {
ExitRule();
}
return(_localctx);
}
