Ejemplo n.º 1
0
        // 11.4 Unary Operators

        private dynamic ParseUnaryExpression()
        {
            //var token, expr;
            var firstToken = _extra.Tokens[_extra.Tokens.Count - 1];

            if (Match("++") || Match("--"))
            {
                var token = Lex();
                var expr = ParseUnaryExpression();
                // 11.4.4, 11.4.5
                if (_strict && expr.Type == Syntax.Identifier && IsRestrictedWord(expr.Name))
                {
                    ThrowError(null, Messages.StrictLHSPrefix);
                }

                if (!IsLeftHandSide(expr))
                {
                    ThrowError(null, Messages.InvalidLHSInAssignment);
                }

                var lastToken = _extra.Tokens[_extra.Tokens.Count - 1];

                expr = new UpdateExpression(_codeGeneration)
                {
                    Operator = token.Value,
                    Argument = expr,
                    Prefix = true,
                    Range = new Range { Start = firstToken.Range.Start, End = lastToken.Range.End },
                    Loc =
                        new Loc
                        {
                            Start = new Loc.Position { Line = firstToken.Loc.Start.Line, Column = firstToken.Loc.Start.Column },
                            End = new Loc.Position { Line = lastToken.Loc.End.Line, Column = lastToken.Loc.End.Column }
                        }
                };
                return expr;
            }

            if (Match('+') || Match('-') || Match('~') || Match('!'))
            {
                var expr = new
                {
                    Type = Syntax.UnaryExpression,
                    Operator = Lex().Value,
                    Argument = ParseUnaryExpression()
                };
                return expr;
            }

            if (MatchKeyword("delete") || MatchKeyword("void") || MatchKeyword("typeof"))
            {
                var expr = new
                {
                    Type = Syntax.UnaryExpression,
                    Operator = Lex().Value,
                    Argument = ParseUnaryExpression()
                };
                if (_strict && expr.Operator == "delete" && expr.Argument.Type == Syntax.Identifier)
                {
                    ThrowErrorTolerant(null, Messages.StrictDelete);
                }
                return expr;
            }

            return ParsePostfixExpression();
        }
Ejemplo n.º 2
0
        // 11.3 Postfix Expressions

        private dynamic ParsePostfixExpression()
        {
            var expr = ParseLeftHandSideExpressionAllowCall();

            var firstToken = _extra.Tokens[_extra.Tokens.Count - 1];

            if ((Match("++") || Match("--")) && !PeekLineTerminator())
            {
                // 11.3.1, 11.3.2
                if (_strict && expr.Type == Syntax.Identifier && IsRestrictedWord(expr.Name))
                {
                    ThrowError(null, Messages.StrictLHSPostfix);
                }

                if (!IsLeftHandSide(expr))
                {
                    ThrowError(null, Messages.InvalidLHSInAssignment);
                }

                var lastToken = _extra.Tokens[_extra.Tokens.Count - 1];

                expr = new UpdateExpression(_codeGeneration)
                {
                    Operator = Lex().Value,
                    Argument = expr,
                    Prefix = false,
                    Range = new Range { Start = firstToken.Range.Start, End = lastToken.Range.End },
                    Loc =
                        new Loc
                        {
                            Start = new Loc.Position { Line = firstToken.Loc.Start.Line, Column = firstToken.Loc.Start.Column },
                            End = new Loc.Position { Line = lastToken.Loc.End.Line, Column = lastToken.Loc.End.Column }
                        }
                };
            }

            return expr;
        }