示例#1
0
        // 13 Statements

        public Node parseStatement()
        {
            var type = lookahead.type;
            Node expr = null;
            List<Node> labeledBody;
            string key;
            Node node;

            if (type == TokenType.EOF)
            {
                throwUnexpectedToken(lookahead);
            }

            if (type == TokenType.Punctuator && lookahead.value == "{")
            {
                return parseBlock();
            }
            isAssignmentTarget = isBindingElement = true;
            node = new Node();

            if (type == TokenType.Punctuator)
            {
                switch (lookahead.value)
                {
                    case ";":
                        return parseEmptyStatement(node);
                    case "(":
                        return parseExpressionStatement(node);
                    default:
                        break;
                }
            }
            else if (type == TokenType.Keyword)
            {
                switch (lookahead.value)
                {
                    case "break":
                        return parseBreakStatement(node);
                    case "continue":
                        return parseContinueStatement(node);
                    case "debugger":
                        return parseDebuggerStatement(node);
                    case "do":
                        return parseDoWhileStatement(node);
                    case "for":
                        return parseForStatement(node);
                    case "function":
                        return parseFunctionDeclaration(node);
                    case "if":
                        return parseIfStatement(node);
                    case "return":
                        return parseReturnStatement(node);
                    case "switch":
                        return parseSwitchStatement(node);
                    case "throw":
                        return parseThrowStatement(node);
                    case "try":
                        return parseTryStatement(node);
                    case "var":
                        return parseVariableStatement(node);
                    case "while":
                        return parseWhileStatement(node);
                    case "with":
                        return parseWithStatement(node);
                    default:
                        break;
                }
            }

            expr = parseExpression();

            // ECMA-262 12.12 Labelled Statements
            if ((expr.type == Syntax.Identifier) && match(":"))
            {
                lex();

                key = "$" + expr.name;
                //if (Object.prototype.hasOwnProperty.call(state.labelSet, key)) {
                //    throwError(Messages.Redeclaration, "Label", expr.name);
                //}

                state.labelSet.Add(key);// = true;
                labeledBody = new List<Node>() { parseStatement() };
                state.labelSet.Remove(key);
                return node.finishLabeledStatement(expr, labeledBody);
            }

            consumeSemicolon();

            return node.finishExpressionStatement(expr);
        }
示例#2
0
        // ECMA-262 12.4 Expression Statement

        public Node parseExpressionStatement(Node node)
        {
            var expr = parseExpression();
            consumeSemicolon();
            return node.finishExpressionStatement(expr);
        }