Esempio n. 1
0
        internal AssignmentStatement(ContextScope scope, Lexer lexer) : base(scope, lexer)
        {
            // VARIABLE = EXPR;
            // VARIABLE += EXPR;
            // VARIABLE -= EXPR;
            // VARIABLE *= EXPR;
            // VARIABLE /= EXPR;
            // VARIABLE %= EXPR;
            // VARIABLE &= EXPR;
            // VARIABLE |= EXPR;
            // TO DO: VARIABLE++/--;
            // or
            // EXPR;

            _scope = scope;
            switch (lexer.TokenType)
            {
            case TokenEnum.VARIABLE:
            {
                if (Parser.TypeTokens[lexer.TokenContents] != null)
                {
                    DeclVariable d = new DeclVariable(scope, lexer);
                    _varExpr = d;
                    _varName = d.varName;
                }
                else
                {
                    _varName = lexer.TokenContents;
                    _varExpr = new IndexedExpression(scope, lexer).Get();
                }

                _assigntype = lexer.TokenType;
                if (_assigntype == TokenEnum.ASSIGN ||
                    _assigntype == TokenEnum.PLUSASSIGN ||
                    _assigntype == TokenEnum.MINUSASSIGN ||
                    _assigntype == TokenEnum.ASTERISKASSIGN ||
                    _assigntype == TokenEnum.SLASHASSIGN ||
                    _assigntype == TokenEnum.PERCENTASSIGN ||
                    _assigntype == TokenEnum.AMPASSIGN ||
                    _assigntype == TokenEnum.PIPEASSIGN
                    )
                {
                    lexer.Next(); //ASSIGN
                    _value = new Expression(scope, lexer).Get();
                }
                else
                {
                    _assigntype = TokenEnum.NOTHING;
                }
            }
            break;

            default:
            {
                _assigntype = TokenEnum.NOTHING;
                _value      = new Expression(scope, lexer).Get();
            }
            break;
            }
        }
Esempio n. 2
0
        internal ForEachStatement(ContextScope scope, Lexer lexer) : base(scope, lexer)
        {
            // FOREACH ( DECL VAR IN EXPR ) STATEMENT
            // FOREACH ( DECL VAR IN EXPR ) { STATEMENT STATEMENT STATEMENT ... }
            // or
            // ASSIGNMENTEXPR

            if (lexer.TokenType == TokenEnum.FOREACH)
            {
                lexer.Next(); //FOREACH
                if (lexer.TokenType != TokenEnum.BRACKETOPEN)
                {
                    throw new ParseException(lexer, TokenEnum.BRACKETOPEN);
                }
                lexer.Next(); //BRACKETOPEN

                _scope = scope.Next;
                _var   = new DeclVariable(_scope, lexer);

                if (lexer.TokenType != TokenEnum.IN)
                {
                    throw new ParseException(lexer, TokenEnum.IN);
                }
                lexer.Next(); //IN

                _enumerable = new Expression(_scope, lexer).Get();

                if (lexer.TokenType != TokenEnum.BRACKETCLOSE)
                {
                    throw new ParseException(lexer, TokenEnum.BRACKETCLOSE);
                }
                lexer.Next(); //BRACKETCLOSE

                if (lexer.TokenType == TokenEnum.BRACEOPEN)
                {
                    lexer.Next(); //BRACEOPEN
                    while (lexer.TokenType != TokenEnum.BRACECLOSE)
                    {
                        _actions.Add(new Statement(_scope, lexer).Get());
                    }
                    lexer.Next(); //BRACECLOSE
                }
                else
                {
                    _actions.Add(new Statement(scope, lexer).Get());
                }
            }
            else
            {
                _actions.Add(GetNext(scope, lexer));
            }
        }