public AtomContext atom()
        {
            AtomContext _localctx = new AtomContext(Context, State);

            EnterRule(_localctx, 18, RULE_atom);
            int _la;

            try {
                EnterOuterAlt(_localctx, 1);
                {
                    State = 100;
                    _la   = TokenStream.LA(1);
                    if (!(_la == ID || _la == DIGIT))
                    {
                        ErrorHandler.RecoverInline(this);
                    }
                    else
                    {
                        ErrorHandler.ReportMatch(this);
                        Consume();
                    }
                }
            }
            catch (RecognitionException re) {
                _localctx.exception = re;
                ErrorHandler.ReportError(this, re);
                ErrorHandler.Recover(this, re);
            }
            finally {
                ExitRule();
            }
            return(_localctx);
        }
        public AtomContext atom()
        {
            AtomContext _localctx = new AtomContext(Context, State);

            EnterRule(_localctx, 8, RULE_atom);
            int _la;

            try {
                EnterOuterAlt(_localctx, 1);
                {
                    State = 44;
                    _la   = TokenStream.LA(1);
                    if (!((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NUMBER) | (1L << STRING) | (1L << SYMBOL))) != 0)))
                    {
                        ErrorHandler.RecoverInline(this);
                    }
                    else
                    {
                        ErrorHandler.ReportMatch(this);
                        Consume();
                    }
                }
            }
            catch (RecognitionException re) {
                _localctx.exception = re;
                ErrorHandler.ReportError(this, re);
                ErrorHandler.Recover(this, re);
            }
            finally {
                ExitRule();
            }
            return(_localctx);
        }
    public AtomContext atom()
    {
        AtomContext _localctx = new AtomContext(Context, State);

        EnterRule(_localctx, 10, RULE_atom);
        try {
            State = 67;
            ErrorHandler.Sync(this);
            switch (TokenStream.LA(1))
            {
            case SCIENTIFIC_NUMBER:
                EnterOuterAlt(_localctx, 1);
                {
                    State = 60; scientific();
                }
                break;

            case VARIABLE:
                EnterOuterAlt(_localctx, 2);
                {
                    State = 61; variable();
                }
                break;

            case PI:
            case EULER:
            case I:
                EnterOuterAlt(_localctx, 3);
                {
                    State = 62; constant();
                }
                break;

            case LPAREN:
                EnterOuterAlt(_localctx, 4);
                {
                    State = 63; Match(LPAREN);
                    State = 64; expression();
                    State = 65; Match(RPAREN);
                }
                break;

            default:
                throw new NoViableAltException(this);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            ErrorHandler.ReportError(this, re);
            ErrorHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return(_localctx);
    }
Exemple #4
0
    public AtomContext atom()
    {
        AtomContext _localctx = new AtomContext(_ctx, State);

        EnterRule(_localctx, 12, RULE_atom);
        try {
            State = 71;
            _errHandler.Sync(this);
            switch (_input.La(1))
            {
            case NUMBER:
                EnterOuterAlt(_localctx, 1);
                {
                    State = 64; number();
                }
                break;

            case VARIABLE:
                EnterOuterAlt(_localctx, 2);
                {
                    State = 65; variable();
                }
                break;

            case LBRACK:
                EnterOuterAlt(_localctx, 3);
                {
                    State = 66; multiDensityList();
                }
                break;

            case LPAREN:
                EnterOuterAlt(_localctx, 4);
                {
                    State = 67; Match(LPAREN);
                    State = 68; density();
                    State = 69; Match(RPAREN);
                }
                break;

            default:
                throw new NoViableAltException(this);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            _errHandler.ReportError(this, re);
            _errHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return(_localctx);
    }
Exemple #5
0
    public AtomContext atom()
    {
        AtomContext _localctx = new AtomContext(Context, State);

        EnterRule(_localctx, 8, RULE_atom);
        try {
            State = 52;
            ErrorHandler.Sync(this);
            switch (TokenStream.LA(1))
            {
            case ID:
                EnterOuterAlt(_localctx, 1);
                {
                    State = 46; Match(ID);
                }
                break;

            case INT:
                EnterOuterAlt(_localctx, 2);
                {
                    State = 47; Match(INT);
                }
                break;

            case T__0:
                EnterOuterAlt(_localctx, 3);
                {
                    State = 48; Match(T__0);
                    State = 49; expr();
                    State = 50; Match(T__1);
                }
                break;

            default:
                throw new NoViableAltException(this);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            ErrorHandler.ReportError(this, re);
            ErrorHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return(_localctx);
    }
Exemple #6
0
    public AtomContext atom()
    {
        AtomContext _localctx = new AtomContext(Context, State);

        EnterRule(_localctx, 8, RULE_atom);
        try {
            EnterOuterAlt(_localctx, 1);
            {
                State = 30; Match(NUMBER);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            ErrorHandler.ReportError(this, re);
            ErrorHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return(_localctx);
    }
    public AtomContext atom()
    {
        AtomContext _localctx = new AtomContext(Context, State);

        EnterRule(_localctx, 4, RULE_atom);
        try {
            State = 50;
            ErrorHandler.Sync(this);
            switch (TokenStream.LA(1))
            {
            case SCIENTIFIC_NUMBER:
                EnterOuterAlt(_localctx, 1);
                {
                    State = 48;
                    scientific();
                }
                break;

            case VARIABLE:
                EnterOuterAlt(_localctx, 2);
                {
                    State = 49;
                    variable();
                }
                break;

            default:
                throw new NoViableAltException(this);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            ErrorHandler.ReportError(this, re);
            ErrorHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return(_localctx);
    }
        public AtomContext atom()
        {
            AtomContext _localctx = new AtomContext(_ctx, State);

            EnterRule(_localctx, 18, RULE_atom);
            int _la;

            try {
                EnterOuterAlt(_localctx, 1);
                {
                    State = 100;
                    _la   = _input.La(1);
                    if (!(_la == ID || _la == DIGIT))
                    {
                        _errHandler.RecoverInline(this);
                    }
                    else
                    {
                        if (_input.La(1) == TokenConstants.Eof)
                        {
                            matchedEOF = true;
                        }

                        _errHandler.ReportMatch(this);
                        Consume();
                    }
                }
            }
            catch (RecognitionException re) {
                _localctx.exception = re;
                _errHandler.ReportError(this, re);
                _errHandler.Recover(this, re);
            }
            finally {
                ExitRule();
            }
            return(_localctx);
        }
Exemple #9
0
    public AtomContext atom()
    {
        AtomContext _localctx = new AtomContext(Context, State);

        EnterRule(_localctx, 0, RULE_atom);
        int _la;

        try {
            EnterOuterAlt(_localctx, 1);
            {
                State = 4; Match(T__0);
                State = 8;
                ErrorHandler.Sync(this);
                _la = TokenStream.LA(1);
                while (_la == IDENTIFIER)
                {
                    {
                        {
                            State = 5; Match(IDENTIFIER);
                        }
                    }
                    State = 10;
                    ErrorHandler.Sync(this);
                    _la = TokenStream.LA(1);
                }
                State = 11; Match(T__1);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            ErrorHandler.ReportError(this, re);
            ErrorHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return(_localctx);
    }
	public AtomContext atom() {
		AtomContext _localctx = new AtomContext(Context, State);
		EnterRule(_localctx, 128, RULE_atom);
		int _la;
		try {
			State = 855;
			switch (TokenStream.La(1)) {
			case OPEN_PAREN:
				EnterOuterAlt(_localctx, 1);
				{
				State = 828; Match(OPEN_PAREN);
				State = 831;
				switch (TokenStream.La(1)) {
				case YIELD:
					{
					State = 829; yield_expr();
					}
					break;
				case LAMBDA:
				case NOT:
				case NONE:
				case TRUE:
				case FALSE:
				case NAME:
				case STRING_LITERAL:
				case BYTES_LITERAL:
				case DECIMAL_INTEGER:
				case OCT_INTEGER:
				case HEX_INTEGER:
				case BIN_INTEGER:
				case FLOAT_NUMBER:
				case IMAG_NUMBER:
				case ELLIPSIS:
				case STAR:
				case OPEN_PAREN:
				case OPEN_BRACK:
				case ADD:
				case MINUS:
				case NOT_OP:
				case OPEN_BRACE:
					{
					State = 830; testlist_comp();
					}
					break;
				case CLOSE_PAREN:
					break;
				default:
					throw new NoViableAltException(this);
				}
				State = 833; Match(CLOSE_PAREN);
				}
				break;
			case OPEN_BRACK:
				EnterOuterAlt(_localctx, 2);
				{
				State = 834; Match(OPEN_BRACK);
				State = 836;
				_la = TokenStream.La(1);
				if (((((_la - 20)) & ~0x3f) == 0 && ((1L << (_la - 20)) & ((1L << (LAMBDA - 20)) | (1L << (NOT - 20)) | (1L << (NONE - 20)) | (1L << (TRUE - 20)) | (1L << (FALSE - 20)) | (1L << (NAME - 20)) | (1L << (STRING_LITERAL - 20)) | (1L << (BYTES_LITERAL - 20)) | (1L << (DECIMAL_INTEGER - 20)) | (1L << (OCT_INTEGER - 20)) | (1L << (HEX_INTEGER - 20)) | (1L << (BIN_INTEGER - 20)) | (1L << (FLOAT_NUMBER - 20)) | (1L << (IMAG_NUMBER - 20)) | (1L << (ELLIPSIS - 20)) | (1L << (STAR - 20)) | (1L << (OPEN_PAREN - 20)) | (1L << (OPEN_BRACK - 20)) | (1L << (ADD - 20)) | (1L << (MINUS - 20)) | (1L << (NOT_OP - 20)) | (1L << (OPEN_BRACE - 20)))) != 0)) {
					{
					State = 835; testlist_comp();
					}
				}

				State = 838; Match(CLOSE_BRACK);
				}
				break;
			case OPEN_BRACE:
				EnterOuterAlt(_localctx, 3);
				{
				State = 839; Match(OPEN_BRACE);
				State = 841;
				_la = TokenStream.La(1);
				if (((((_la - 20)) & ~0x3f) == 0 && ((1L << (_la - 20)) & ((1L << (LAMBDA - 20)) | (1L << (NOT - 20)) | (1L << (NONE - 20)) | (1L << (TRUE - 20)) | (1L << (FALSE - 20)) | (1L << (NAME - 20)) | (1L << (STRING_LITERAL - 20)) | (1L << (BYTES_LITERAL - 20)) | (1L << (DECIMAL_INTEGER - 20)) | (1L << (OCT_INTEGER - 20)) | (1L << (HEX_INTEGER - 20)) | (1L << (BIN_INTEGER - 20)) | (1L << (FLOAT_NUMBER - 20)) | (1L << (IMAG_NUMBER - 20)) | (1L << (ELLIPSIS - 20)) | (1L << (STAR - 20)) | (1L << (OPEN_PAREN - 20)) | (1L << (OPEN_BRACK - 20)) | (1L << (ADD - 20)) | (1L << (MINUS - 20)) | (1L << (NOT_OP - 20)) | (1L << (OPEN_BRACE - 20)))) != 0)) {
					{
					State = 840; dictorsetmaker();
					}
				}

				State = 843; Match(CLOSE_BRACE);
				}
				break;
			case NAME:
				EnterOuterAlt(_localctx, 4);
				{
				State = 844; Match(NAME);
				}
				break;
			case DECIMAL_INTEGER:
			case OCT_INTEGER:
			case HEX_INTEGER:
			case BIN_INTEGER:
			case FLOAT_NUMBER:
			case IMAG_NUMBER:
				EnterOuterAlt(_localctx, 5);
				{
				State = 845; number();
				}
				break;
			case STRING_LITERAL:
			case BYTES_LITERAL:
				EnterOuterAlt(_localctx, 6);
				{
				State = 847;
				ErrorHandler.Sync(this);
				_la = TokenStream.La(1);
				do {
					{
					{
					State = 846; @string();
					}
					}
					State = 849;
					ErrorHandler.Sync(this);
					_la = TokenStream.La(1);
				} while ( _la==STRING_LITERAL || _la==BYTES_LITERAL );
				}
				break;
			case ELLIPSIS:
				EnterOuterAlt(_localctx, 7);
				{
				State = 851; Match(ELLIPSIS);
				}
				break;
			case NONE:
				EnterOuterAlt(_localctx, 8);
				{
				State = 852; Match(NONE);
				}
				break;
			case TRUE:
				EnterOuterAlt(_localctx, 9);
				{
				State = 853; Match(TRUE);
				}
				break;
			case FALSE:
				EnterOuterAlt(_localctx, 10);
				{
				State = 854; Match(FALSE);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			ErrorHandler.ReportError(this, re);
			ErrorHandler.Recover(this, re);
		}
		finally {
			ExitRule();
		}
		return _localctx;
	}
 public ConstantPIContext(AtomContext context)
 {
     CopyFrom(context);
 }
 public virtual void CopyFrom(AtomContext context)
 {
     base.CopyFrom(context);
 }
 public IntContext(AtomContext context)
 {
     CopyFrom(context);
 }
 public DoubleContext(AtomContext context)
 {
     CopyFrom(context);
 }
 public BracesContext(AtomContext context)
 {
     CopyFrom(context);
 }
 public VariableContext(AtomContext context)
 {
     CopyFrom(context);
 }
    public AtomContext atom()
    {
        AtomContext _localctx = new AtomContext(Context, State);

        EnterRule(_localctx, 14, RULE_atom);
        try {
            State = 104;
            ErrorHandler.Sync(this);
            switch (Interpreter.AdaptivePredict(TokenStream, 8, Context))
            {
            case 1:
                EnterOuterAlt(_localctx, 1);
                {
                    State           = 85; _localctx._NUMBER = Match(NUMBER);
                    _localctx.value = ComplexNumber.Parse((_localctx._NUMBER != null?_localctx._NUMBER.Text:null));
                }
                break;

            case 2:
                EnterOuterAlt(_localctx, 2);
                {
                    State           = 87; _localctx._ID = Match(ID);
                    _localctx.value = new VariableEntity((_localctx._ID != null?_localctx._ID.Text:null));
                }
                break;

            case 3:
                EnterOuterAlt(_localctx, 3);
                {
                    State           = 89; Match(T__5);
                    State           = 90; _localctx._expression = expression();
                    State           = 91; Match(T__6);
                    _localctx.value = _localctx._expression.value;
                }
                break;

            case 4:
                EnterOuterAlt(_localctx, 4);
                {
                    State           = 94; _localctx._ID = Match(ID);
                    State           = 95; Match(T__5);
                    State           = 96; _localctx.args = function_arguments();
                    State           = 97; Match(T__6);
                    _localctx.value = new FunctionEntity((_localctx._ID != null?_localctx._ID.Text:null) + 'f'); foreach (var arg in _localctx.args.list)
                    {
                        _localctx.value.Children.Add(arg);
                    }
                }
                break;

            case 5:
                EnterOuterAlt(_localctx, 5);
                {
                    State           = 100; _localctx._ID = Match(ID);
                    State           = 101; Match(T__5);
                    State           = 102; Match(T__6);
                    _localctx.value = new FunctionEntity((_localctx._ID != null?_localctx._ID.Text:null) + 'f');
                }
                break;
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            ErrorHandler.ReportError(this, re);
            ErrorHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return(_localctx);
    }
    public AtomContext atom()
    {
        AtomContext _localctx = new AtomContext(Context, State);

        EnterRule(_localctx, 12, RULE_atom);
        try {
            State = 77;
            ErrorHandler.Sync(this);
            switch (TokenStream.LA(1))
            {
            case PI:
                _localctx = new ConstantPIContext(_localctx);
                EnterOuterAlt(_localctx, 1);
                {
                    State = 68; Match(PI);
                }
                break;

            case E:
                _localctx = new ConstantEContext(_localctx);
                EnterOuterAlt(_localctx, 2);
                {
                    State = 69; Match(E);
                }
                break;

            case DOUBLE:
                _localctx = new DoubleContext(_localctx);
                EnterOuterAlt(_localctx, 3);
                {
                    State = 70; Match(DOUBLE);
                }
                break;

            case INT:
                _localctx = new IntContext(_localctx);
                EnterOuterAlt(_localctx, 4);
                {
                    State = 71; Match(INT);
                }
                break;

            case ID:
                _localctx = new VariableContext(_localctx);
                EnterOuterAlt(_localctx, 5);
                {
                    State = 72; Match(ID);
                }
                break;

            case LPAR:
                _localctx = new BracesContext(_localctx);
                EnterOuterAlt(_localctx, 6);
                {
                    State = 73; Match(LPAR);
                    State = 74; plusOrMinus(0);
                    State = 75; Match(RPAR);
                }
                break;

            default:
                throw new NoViableAltException(this);
            }
        }
        catch (RecognitionException re) {
            _localctx.exception = re;
            ErrorHandler.ReportError(this, re);
            ErrorHandler.Recover(this, re);
        }
        finally {
            ExitRule();
        }
        return(_localctx);
    }