/*

 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package jdk.nashorn.internal.parser;

import static jdk.nashorn.internal.codegen.CompilerConstants.ARGUMENTS;

import static jdk.nashorn.internal.codegen.CompilerConstants.EVAL;

import static jdk.nashorn.internal.codegen.CompilerConstants.FUNCTION_PREFIX;

import static jdk.nashorn.internal.codegen.CompilerConstants.RUN_SCRIPT;

import static jdk.nashorn.internal.parser.TokenType.ASSIGN;

import static jdk.nashorn.internal.parser.TokenType.CASE;

import static jdk.nashorn.internal.parser.TokenType.CATCH;

import static jdk.nashorn.internal.parser.TokenType.COLON;

import static jdk.nashorn.internal.parser.TokenType.COMMARIGHT;

import static jdk.nashorn.internal.parser.TokenType.DECPOSTFIX;

import static jdk.nashorn.internal.parser.TokenType.DECPREFIX;

import static jdk.nashorn.internal.parser.TokenType.ELSE;

import static jdk.nashorn.internal.parser.TokenType.EOF;

import static jdk.nashorn.internal.parser.TokenType.EOL;

import static jdk.nashorn.internal.parser.TokenType.FINALLY;

import static jdk.nashorn.internal.parser.TokenType.FUNCTION;

import static jdk.nashorn.internal.parser.TokenType.IDENT;

import static jdk.nashorn.internal.parser.TokenType.IF;

import static jdk.nashorn.internal.parser.TokenType.INCPOSTFIX;

import static jdk.nashorn.internal.parser.TokenType.LBRACE;

import static jdk.nashorn.internal.parser.TokenType.LPAREN;

import static jdk.nashorn.internal.parser.TokenType.RBRACE;

import static jdk.nashorn.internal.parser.TokenType.RBRACKET;

import static jdk.nashorn.internal.parser.TokenType.RPAREN;

import static jdk.nashorn.internal.parser.TokenType.SEMICOLON;

import static jdk.nashorn.internal.parser.TokenType.TERNARY;

import static jdk.nashorn.internal.parser.TokenType.WHILE;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import jdk.nashorn.internal.codegen.CompilerConstants;

import jdk.nashorn.internal.codegen.Namespace;

import jdk.nashorn.internal.ir.AccessNode;

import jdk.nashorn.internal.ir.BaseNode;

import jdk.nashorn.internal.ir.BinaryNode;

import jdk.nashorn.internal.ir.Block;

import jdk.nashorn.internal.ir.BlockLexicalContext;

import jdk.nashorn.internal.ir.BreakNode;

import jdk.nashorn.internal.ir.BreakableNode;

import jdk.nashorn.internal.ir.CallNode;

import jdk.nashorn.internal.ir.CaseNode;

import jdk.nashorn.internal.ir.CatchNode;

import jdk.nashorn.internal.ir.ContinueNode;

import jdk.nashorn.internal.ir.EmptyNode;

import jdk.nashorn.internal.ir.ExecuteNode;

import jdk.nashorn.internal.ir.ForNode;

import jdk.nashorn.internal.ir.FunctionNode;

import jdk.nashorn.internal.ir.FunctionNode.CompilationState;

import jdk.nashorn.internal.ir.IdentNode;

import jdk.nashorn.internal.ir.IfNode;

import jdk.nashorn.internal.ir.IndexNode;

import jdk.nashorn.internal.ir.LabelNode;

import jdk.nashorn.internal.ir.LexicalContext;

import jdk.nashorn.internal.ir.LiteralNode;

import jdk.nashorn.internal.ir.LoopNode;

import jdk.nashorn.internal.ir.Node;

import jdk.nashorn.internal.ir.ObjectNode;

import jdk.nashorn.internal.ir.PropertyKey;

import jdk.nashorn.internal.ir.PropertyNode;

import jdk.nashorn.internal.ir.ReturnNode;

import jdk.nashorn.internal.ir.RuntimeNode;

import jdk.nashorn.internal.ir.Statement;

import jdk.nashorn.internal.ir.SwitchNode;

import jdk.nashorn.internal.ir.TernaryNode;

import jdk.nashorn.internal.ir.ThrowNode;

import jdk.nashorn.internal.ir.TryNode;

import jdk.nashorn.internal.ir.UnaryNode;

import jdk.nashorn.internal.ir.VarNode;

import jdk.nashorn.internal.ir.WhileNode;

import jdk.nashorn.internal.ir.WithNode;

import jdk.nashorn.internal.runtime.DebugLogger;

import jdk.nashorn.internal.runtime.ErrorManager;

import jdk.nashorn.internal.runtime.JSErrorType;

import jdk.nashorn.internal.runtime.ParserException;

import jdk.nashorn.internal.runtime.ScriptEnvironment;

import jdk.nashorn.internal.runtime.ScriptingFunctions;

import jdk.nashorn.internal.runtime.Source;

import jdk.nashorn.internal.runtime.Timing;

/**

 * Builds the IR.

 */

public class Parser extends AbstractParser {

    /** Current script environment. */

    private final ScriptEnvironment env;

    /** Is scripting mode. */

    private final boolean scripting;

    private List<Statement> functionDeclarations;

    private final BlockLexicalContext lc = new BlockLexicalContext();

    /** Namespace for function names where not explicitly given */

    private final Namespace namespace;

    private static final DebugLogger LOG = new DebugLogger("parser");

    /**

     * Constructor

     *

     * @param env     script environment

     * @param source  source to parse

     * @param errors  error manager

     */

    public Parser(final ScriptEnvironment env, final Source source, final ErrorManager errors) {

        this(env, source, errors, env._strict);

    }

    /**

     * Construct a parser.

     *

     * @param env     script environment

     * @param source  source to parse

     * @param errors  error manager

     * @param strict  parser created with strict mode enabled.

     */

    public Parser(final ScriptEnvironment env, final Source source, final ErrorManager errors, final boolean strict) {

        super(source, errors, strict);

        this.env       = env;

        this.namespace = new Namespace(env.getNamespace());

        this.scripting = env._scripting;

    }

    /**

     * Execute parse and return the resulting function node.

     * Errors will be thrown and the error manager will contain information

     * if parsing should fail

     *

     * This is the default parse call, which will name the function node

     * "runScript" {@link CompilerConstants#RUN_SCRIPT}

     *

     * @return function node resulting from successful parse

     */

    public FunctionNode parse() {

        return parse(RUN_SCRIPT.symbolName());

    }

    /**

     * Execute parse and return the resulting function node.

     * Errors will be thrown and the error manager will contain information

     * if parsing should fail

     *

     * @param scriptName name for the script, given to the parsed FunctionNode

     *

     * @return function node resulting from successful parse

     */

    public FunctionNode parse(final String scriptName) {

        final long t0 = Timing.isEnabled() ? System.currentTimeMillis() : 0L;

        LOG.info(this, " begin for '", scriptName, "'");

        try {

            stream = new TokenStream();

            lexer  = new Lexer(source, stream, scripting && !env._no_syntax_extensions);

            // Set up first token (skips opening EOL.)

            k = -1;

            next();

            // Begin parse.

            return program(scriptName);

        } catch (final Exception e) {

            handleParseException(e);

            return null;

        } finally {

            final String end = this + " end '" + scriptName + "'";

            if (Timing.isEnabled()) {

                Timing.accumulateTime(toString(), System.currentTimeMillis() - t0);

                LOG.info(end, "' in ", (System.currentTimeMillis() - t0), " ms");

            } else {

                LOG.info(end);

            }

        }

    }

    /**

     * Parse and return the list of function parameter list. A comma

     * separated list of function parameter identifiers is expected to be parsed.

     * Errors will be thrown and the error manager will contain information

     * if parsing should fail. This method is used to check if parameter Strings

     * passed to "Function" constructor is a valid or not.

     *

     * @return the list of IdentNodes representing the formal parameter list

     */

    public List<IdentNode> parseFormalParameterList() {

        try {

            stream = new TokenStream();

            lexer  = new Lexer(source, stream, scripting && !env._no_syntax_extensions);

            // Set up first token (skips opening EOL.)

            k = -1;

            next();

            return formalParameterList(TokenType.EOF);

        } catch (final Exception e) {

            handleParseException(e);

            return null;

        }

    }

    /**

     * Execute parse and return the resulting function node.

     * Errors will be thrown and the error manager will contain information

     * if parsing should fail. This method is used to check if code String

     * passed to "Function" constructor is a valid function body or not.

     *

     * @return function node resulting from successful parse

     */

    public FunctionNode parseFunctionBody() {

        try {

            stream = new TokenStream();

            lexer  = new Lexer(source, stream, scripting && !env._no_syntax_extensions);

            // Set up first token (skips opening EOL.)

            k = -1;

            next();

            // Make a fake token for the function.

            final long functionToken = Token.toDesc(FUNCTION, 0, source.getLength());

            // Set up the function to append elements.

            FunctionNode function = newFunctionNode(

                functionToken,

                new IdentNode(functionToken, Token.descPosition(functionToken), RUN_SCRIPT.symbolName()),

                new ArrayList<IdentNode>(),

                FunctionNode.Kind.NORMAL);

            functionDeclarations = new ArrayList<>();

            sourceElements();

            addFunctionDeclarations(function);

            functionDeclarations = null;

            expect(EOF);

            function.setFinish(source.getLength() - 1);

            function = restoreFunctionNode(function, token); //commit code

            function = function.setBody(lc, function.getBody().setNeedsScope(lc));

            return function;

        } catch (final Exception e) {

            handleParseException(e);

            return null;

        }

    }

    private void handleParseException(final Exception e) {

        // Extract message from exception.  The message will be in error

        // message format.

        String message = e.getMessage();

        // If empty message.

        if (message == null) {

            message = e.toString();

        }

        // Issue message.

        if (e instanceof ParserException) {

            errors.error((ParserException)e);

        } else {

            errors.error(message);

        }

        if (env._dump_on_error) {

            e.printStackTrace(env.getErr());

        }

    }

    /**

     * Skip to a good parsing recovery point.

     */

    private void recover(final Exception e) {

        if (e != null) {

            // Extract message from exception.  The message will be in error

            // message format.

            String message = e.getMessage();

            // If empty message.

            if (message == null) {

                message = e.toString();

            }

            // Issue message.

            if (e instanceof ParserException) {

                errors.error((ParserException)e);

            } else {

                errors.error(message);

            }

            if (env._dump_on_error) {

                e.printStackTrace(env.getErr());

            }

        }

        // Skip to a recovery point.

loop:

        while (true) {

            switch (type) {

            case EOF:

                // Can not go any further.

                break loop;

            case EOL:

            case SEMICOLON:

            case RBRACE:

                // Good recovery points.

                next();

                break loop;

            default:

                // So we can recover after EOL.

                nextOrEOL();

                break;

            }

        }

    }

    /**

     * Set up a new block.

     *

     * @return New block.

     */

    private Block newBlock() {

        return lc.push(new Block(line, token, Token.descPosition(token)));

    }

    /**

     * Set up a new function block.

     *

     * @param ident Name of function.

     * @return New block.

     */

    private FunctionNode newFunctionNode(final long startToken, final IdentNode ident, final List<IdentNode> parameters, final FunctionNode.Kind kind) {

        // Build function name.

        final StringBuilder sb = new StringBuilder();

        final FunctionNode parentFunction = lc.getCurrentFunction();

        if (parentFunction != null && !parentFunction.isProgram()) {

            sb.append(parentFunction.getName()).append('$');

        }

        sb.append(ident != null ? ident.getName() : FUNCTION_PREFIX.symbolName());

        final String name = namespace.uniqueName(sb.toString());

        assert parentFunction != null || name.equals(RUN_SCRIPT.symbolName())  : "name = " + name;// must not rename runScript().

        int flags = 0;

        if (parentFunction == null) {

            flags |= FunctionNode.IS_PROGRAM;

        }

        if (isStrictMode) {

            flags |= FunctionNode.IS_STRICT;

        }

        if (env._specialize_calls != null) {

            if (env._specialize_calls.contains(name)) {

                flags |= FunctionNode.CAN_SPECIALIZE;

            }

        }

        // Start new block.

        FunctionNode functionNode =

            new FunctionNode(

                source,

                line, //TODO?

                token,

                Token.descPosition(token),

                startToken,

                namespace,

                ident,

                name,

                parameters,

                kind,

                flags);

        lc.push(functionNode);

        // Create new block, and just put it on the context stack, restoreFunctionNode() will associate it with the

        // FunctionNode.

        newBlock();

        return functionNode;

    }

    /**

     * Restore the current block.

     */

    private Block restoreBlock(final Block block) {

        return lc.pop(block);

    }

    private FunctionNode restoreFunctionNode(final FunctionNode functionNode, final long lastToken) {

        final Block newBody = restoreBlock(lc.getFunctionBody(functionNode));

        return lc.pop(functionNode).

            setBody(lc, newBody).

            setLastToken(lc, lastToken).

            setState(lc, errors.hasErrors() ? CompilationState.PARSE_ERROR : CompilationState.PARSED).

            snapshot(lc);

        }

    /**

     * Get the statements in a block.

     * @return Block statements.

     */

    private Block getBlock(final boolean needsBraces) {

        // Set up new block. Captures LBRACE.

        Block newBlock = newBlock();

        try {

            // Block opening brace.

            if (needsBraces) {

                expect(LBRACE);

            }

            // Accumulate block statements.

            statementList();

        } finally {

            newBlock = restoreBlock(newBlock);

        }

        final int possibleEnd = Token.descPosition(token) + Token.descLength(token);

        // Block closing brace.

        if (needsBraces) {

            expect(RBRACE);

        }

        newBlock.setFinish(possibleEnd);

        return newBlock;

    }

    /**

     * Get all the statements generated by a single statement.

     * @return Statements.

     */

    private Block getStatement() {

        if (type == LBRACE) {

            return getBlock(true);

        }

        // Set up new block. Captures first token.

        Block newBlock = newBlock();

        try {

            statement();

        } finally {

            newBlock = restoreBlock(newBlock);

        }

        return newBlock;

    }

    /**

     * Detect calls to special functions.

     * @param ident Called function.

     */

    private void detectSpecialFunction(final IdentNode ident) {

        final String name = ident.getName();

        if (EVAL.symbolName().equals(name)) {

            markEval(lc);

        }

    }

    /**

     * Detect use of special properties.

     * @param ident Referenced property.

     */

    private void detectSpecialProperty(final IdentNode ident) {

        final String name = ident.getName();

        if (ARGUMENTS.symbolName().equals(name)) {

            lc.setFlag(lc.getCurrentFunction(), FunctionNode.USES_ARGUMENTS);

        }

    }

    /**

     * Tells whether a IdentNode can be used as L-value of an assignment

     *

     * @param ident IdentNode to be checked