Ejemplo n.º 1
0
    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 SignedAtomContext signedAtom()
    {
        SignedAtomContext _localctx = new SignedAtomContext(Context, State);

        EnterRule(_localctx, 8, RULE_signedAtom);
        try {
            State = 58;
            ErrorHandler.Sync(this);
            switch (TokenStream.LA(1))
            {
            case PLUS:
                EnterOuterAlt(_localctx, 1);
                {
                    State = 52; Match(PLUS);
                    State = 53; signedAtom();
                }
                break;

            case MINUS:
                EnterOuterAlt(_localctx, 2);
                {
                    State = 54; Match(MINUS);
                    State = 55; signedAtom();
                }
                break;

            case COS:
            case SIN:
            case TAN:
            case ACOS:
            case ASIN:
            case ATAN:
            case LN:
            case LOG:
            case SQRT:
                EnterOuterAlt(_localctx, 3);
                {
                    State = 56; func();
                }
                break;

            case LPAREN:
            case PI:
            case EULER:
            case I:
            case VARIABLE:
            case SCIENTIFIC_NUMBER:
                EnterOuterAlt(_localctx, 4);
                {
                    State = 57; atom();
                }
                break;

            default:
                throw new NoViableAltException(this);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            ErrorHandler.ReportError(this, re);
            ErrorHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return(_localctx);
    }
Ejemplo n.º 3
0
 public UnsignedAtomContext(SignedAtomContext context)
 {
     CopyFrom(context);
 }
Ejemplo n.º 4
0
 public PlusAtomContext(SignedAtomContext context)
 {
     CopyFrom(context);
 }
Ejemplo n.º 5
0
 public FunctionContext(SignedAtomContext context)
 {
     CopyFrom(context);
 }
Ejemplo n.º 6
0
 public NegativeAtomContext(SignedAtomContext context)
 {
     CopyFrom(context);
 }
Ejemplo n.º 7
0
 public virtual void CopyFrom(SignedAtomContext context)
 {
     base.CopyFrom(context);
 }