Exemple #1
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);
                }
            }
        }
Exemple #2
0
 Expr IPrefixExpressionVisitor <Expr> .Visit(PrefixExpression.FunctionCall prefixExpr)
 {
     return(prefixExpr.Call.Visit(this));
 }
Exemple #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;
                }
            }
        }
Exemple #4
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;
                }
            }
        }