示例#1
0
        Expr IPrefixExpressionVisitor <Expr> .Visit(PrefixExpression.Variable prefixExpr)
        {
            var variable = prefixExpr.Var.Visit(this);

            switch (variable.Type)
            {
            case VariableType.Identifier:
                ParamExpr local;
                if (scope.TryGetLocal(variable.Identifier, out local))
                {
                    return(local);
                }

                return(Expr.Dynamic(Context.DynamicCache.GetGetMemberBinder(variable.Identifier),
                                    typeof(object), Expr.Constant(context.Globals)));

            case VariableType.MemberId:
                return(Expr.Dynamic(Context.DynamicCache.GetGetMemberBinder(variable.Identifier),
                                    typeof(object), variable.Object));

            case VariableType.MemberExpr:
                return(Expr.Dynamic(Context.DynamicCache.GetGetIndexBinder(), typeof(object),
                                    variable.Object, variable.Member));

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
示例#2
0
        /* Parses prefixExpression
         * variable | functionCall | '(' expression ')' */
        PrefixExpression PrefixExpression()
        {
            // Parse the terminal/first symbol of the prefixExpression
            PrefixExpression left;

            switch (lexer.Current.Symbol)
            {
            case Symbol.Identifier:
                left = new PrefixExpression.Variable(new Variable.Identifier(lexer.ConsumeLexeme()));
                break;

            case Symbol.LeftParen:
                lexer.Consume();
                left = new PrefixExpression.Expression(Expression());
                lexer.ExpectLexeme(Symbol.RightParen);
                break;

            default:
                throw new LuaSyntaxException(input, ExceptionMessage.UNEXPECTED_SYMBOL, lexer.Current.Symbol);
            }

            while (true)
            {
                string identifier;
                switch (lexer.Current.Symbol)
                {
                case Symbol.LeftBrack:
                    lexer.Consume();
                    left = new PrefixExpression.Variable(new Variable.MemberExpr(left, Expression()));
                    lexer.Expect(Symbol.RightBrack);
                    break;

                case Symbol.Dot:
                    lexer.Consume();
                    identifier = lexer.ExpectLexeme(Symbol.Identifier);
                    left       = new PrefixExpression.Variable(new Variable.MemberId(left, identifier));
                    break;

                case Symbol.Colon:
                    lexer.Consume();
                    identifier = lexer.ExpectLexeme(Symbol.Identifier);
                    var arguments = Arguments();
                    left = new PrefixExpression.FunctionCall(new FunctionCall.Table(left, identifier, arguments));
                    break;

                case Symbol.LeftParen:
                case Symbol.LeftBrace:
                case Symbol.String:
                    left = new PrefixExpression.FunctionCall(new FunctionCall.Normal(left, Arguments()));
                    break;

                // Unrecognized symbol, return what we have so far
                default:
                    return(left);
                }
            }
        }
示例#3
0
        /* Parses prefixExpression
         * variable | functionCall | '(' expression ')' */
        PrefixExpression PrefixExpression()
        {
            /* prefixexpr -> NAME | '(' expr ')' */

            // Parse the terminal/first symbol of the prefixExpression
            PrefixExpression left;
            switch (Current.Symbol)
            {
                case Symbol.LeftParen:
                    var leftSpan = Expect(Symbol.LeftParen).Span;
                    var expr = Expression();
                    var rightSpan = ExpectMatch(Symbol.RightParen, Symbol.LeftParen, leftSpan.Start).Span;
                    left = new PrefixExpression.Expression(expr, new SourceSpan(leftSpan.Start, rightSpan.End));
                    break;
                case Symbol.Identifier:
                    var identifier = Consume();
                    var idVar = new Variable.Identifier(identifier.Lexeme) { Span = identifier.Span };
                    left = new PrefixExpression.Variable(idVar);
                    break;
                default:
                    throw ReportSyntaxErrorNear("unexpected symbol");
            }

            /* primaryexpr -> prefixexpr { `.' NAME | `[' expr `]' | `:' NAME funcargs | funcargs } */

            while (true)
            {
                Token identifier;
                switch (Current.Symbol)
                {
                    case Symbol.LeftBrack:
                        var leftSpan = Expect(Symbol.LeftBrack).Span;
                        var expr = Expression();
                        var rightSpan = ExpectMatch(Symbol.RightBrack, Symbol.LeftBrack, leftSpan.Start).Span;
                        var memberExpr = new Variable.MemberExpr(left, expr)
                        {
                            Span = new SourceSpan(left.Span.Start, rightSpan.End)
                        };
                        left = new PrefixExpression.Variable(memberExpr);
                        break;

                    case Symbol.Dot:
                        Consume();
                        identifier = Expect(Symbol.Identifier);
                        var memberId = new Variable.MemberId(left, identifier.Lexeme)
                        {
                            Span = new SourceSpan(left.Span.Start, identifier.Span.End)
                        };
                        left = new PrefixExpression.Variable(memberId);
                        break;

                    case Symbol.Colon:
                        Consume();
                        identifier = Expect(Symbol.Identifier);
                        var arguments = Arguments();
                        left = new PrefixExpression.FunctionCall(new FunctionCall.Table(left, identifier.Lexeme, arguments)
                        {
                            Span = new SourceSpan(left.Span.Start, arguments.Span.End)
                        });
                        break;

                    case Symbol.LeftParen:
                    case Symbol.LeftBrace:
                    case Symbol.String:
                        var args = Arguments();
                        left = new PrefixExpression.FunctionCall(new FunctionCall.Normal(left, args)
                        {
                            Span = new SourceSpan(left.Span.Start, args.Span.End)
                        });
                        break;

                    // Unrecognized symbol, return what we have so far
                    default:
                        return left;
                }
            }
        }
示例#4
0
文件: Parser.cs 项目: ericmj/IronLua
        /* Parses prefixExpression
         * variable | functionCall | '(' expression ')' */
        PrefixExpression PrefixExpression()
        {
            // Parse the terminal/first symbol of the prefixExpression
            PrefixExpression left;
            switch (lexer.Current.Symbol)
            {
                case Symbol.Identifier:
                    left = new PrefixExpression.Variable(new Variable.Identifier(lexer.ConsumeLexeme()));
                    break;
                case Symbol.LeftParen:
                    lexer.Consume();
                    left = new PrefixExpression.Expression(Expression());
                    lexer.ExpectLexeme(Symbol.RightParen);
                    break;
                default:
                    throw new LuaSyntaxException(input, ExceptionMessage.UNEXPECTED_SYMBOL, lexer.Current.Symbol);
            }

            while (true)
            {
                string identifier;
                switch (lexer.Current.Symbol)
                {
                    case Symbol.LeftBrack:
                        lexer.Consume();
                        left = new PrefixExpression.Variable(new Variable.MemberExpr(left, Expression()));
                        lexer.Expect(Symbol.RightBrack);
                        break;

                    case Symbol.Dot:
                        lexer.Consume();
                        identifier = lexer.ExpectLexeme(Symbol.Identifier);
                        left = new PrefixExpression.Variable(new Variable.MemberId(left, identifier));
                        break;

                    case Symbol.Colon:
                        lexer.Consume();
                        identifier = lexer.ExpectLexeme(Symbol.Identifier);
                        var arguments = Arguments();
                        left = new PrefixExpression.FunctionCall(new FunctionCall.Table(left, identifier, arguments));
                        break;

                    case Symbol.LeftParen:
                    case Symbol.LeftBrace:
                    case Symbol.String:
                        left = new PrefixExpression.FunctionCall(new FunctionCall.Normal(left, Arguments()));
                        break;

                    // Unrecognized symbol, return what we have so far
                    default:
                        return left;
                }
            }
        }