/*

 * 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.ANON_FUNCTION_PREFIX;

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

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

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.CONST;

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.ArrayDeque;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Deque;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import jdk.internal.dynalink.support.NameCodec;

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.BlockStatement;

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.Expression;

import jdk.nashorn.internal.ir.ExpressionStatement;

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.JoinPredecessorExpression;

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.ir.debug.ASTWriter;

import jdk.nashorn.internal.ir.debug.PrintVisitor;

import jdk.nashorn.internal.runtime.Context;

import jdk.nashorn.internal.runtime.ErrorManager;

import jdk.nashorn.internal.runtime.JSErrorType;

import jdk.nashorn.internal.runtime.ParserException;

import jdk.nashorn.internal.runtime.RecompilableScriptFunctionData;

import jdk.nashorn.internal.runtime.ScriptEnvironment;

import jdk.nashorn.internal.runtime.ScriptingFunctions;

import jdk.nashorn.internal.runtime.Source;

import jdk.nashorn.internal.runtime.Timing;

import jdk.nashorn.internal.runtime.logging.DebugLogger;

import jdk.nashorn.internal.runtime.logging.Loggable;

import jdk.nashorn.internal.runtime.logging.Logger;

/**

 * Builds the IR.

 */

@Logger(name="parser")

public class Parser extends AbstractParser implements Loggable {

    private static final String ARGUMENTS_NAME = CompilerConstants.ARGUMENTS_VAR.symbolName();

    /** Current env. */

    private final ScriptEnvironment env;

    /** Is scripting mode. */

    private final boolean scripting;

    private List<Statement> functionDeclarations;

    private final BlockLexicalContext lc = new BlockLexicalContext();

    private final Deque<Object> defaultNames = new ArrayDeque<>();

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

    private final Namespace namespace;

    private final DebugLogger log;

    /** to receive line information from Lexer when scanning multine literals. */

    protected final Lexer.LineInfoReceiver lineInfoReceiver;

    private int nextFunctionId;

    /**

     * 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, null);

    }

    /**

     * Constructor

     *

     * @param env     script environment

     * @param source  source to parse

     * @param errors  error manager

     * @param strict  strict

     * @param log debug logger if one is needed

     */

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

        this(env, source, errors, strict, FunctionNode.FIRST_FUNCTION_ID, 0, log);

    }

    /**

     * Construct a parser.

     *

     * @param env     script environment

     * @param source  source to parse

     * @param errors  error manager

     * @param strict  parser created with strict mode enabled.

     * @param nextFunctionId  starting value for assigning new unique ids to function nodes

     * @param lineOffset line offset to start counting lines from

     * @param log debug logger if one is needed

     */

    public Parser(final ScriptEnvironment env, final Source source, final ErrorManager errors, final boolean strict, final int nextFunctionId, final int lineOffset, final DebugLogger log) {

        super(source, errors, strict, lineOffset);

        this.env = env;

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

        this.nextFunctionId    = nextFunctionId;

        this.scripting = env._scripting;

        if (this.scripting) {

            this.lineInfoReceiver = new Lexer.LineInfoReceiver() {

                @Override

                public void lineInfo(final int receiverLine, final int receiverLinePosition) {

                    // update the parser maintained line information

                    Parser.this.line = receiverLine;

                    Parser.this.linePosition = receiverLinePosition;

                }

            };

        } else {

            // non-scripting mode script can't have multi-line literals

            this.lineInfoReceiver = null;

        }

        this.log = log == null ? DebugLogger.DISABLED_LOGGER : log;

    }

    @Override

    public DebugLogger getLogger() {

        return log;

    }

    @Override

    public DebugLogger initLogger(final Context context) {

        return context.getLogger(this.getClass());

    }

    /**

     * Sets the name for the first function. This is only used when reparsing anonymous functions to ensure they can

     * preserve their already assigned name, as that name doesn't appear in their source text.

     * @param name the name for the first parsed function.

     */

    public void setFunctionName(final String name) {

        defaultNames.push(createIdentNode(0, 0, name));

    }

    /**

     * 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

     * {code :program} {@link CompilerConstants#PROGRAM}

     *

     * @return function node resulting from successful parse

     */

    public FunctionNode parse() {

        return parse(PROGRAM.symbolName(), 0, source.getLength(), false);

    }

    /**

     * Execute parse and return the resulting function node.

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

     * if parsing should fail

     *

     * This should be used to create one and only one function node

     *

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

     * @param startPos start position in source

     * @param len length of parse

     * @param allowPropertyFunction if true, "get" and "set" are allowed as first tokens of the program, followed by

     * a property getter or setter function. This is used when reparsing a function that can potentially be defined as a

     * property getter or setter in an object literal.

     *

     * @return function node resulting from successful parse

     */

    public FunctionNode parse(final String scriptName, final int startPos, final int len, final boolean allowPropertyFunction) {

        final boolean isTimingEnabled = env.isTimingEnabled();

        final long t0 = isTimingEnabled ? System.nanoTime() : 0L;

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

        try {

            stream = new TokenStream();

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

            lexer.line = lexer.pendingLine = lineOffset + 1;

            line = lineOffset;

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

            k = -1;

            next();

            // Begin parse.

            return program(scriptName, allowPropertyFunction);

        } catch (final Exception e) {

            handleParseException(e);

            return null;

        } finally {

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

            if (isTimingEnabled) {

                env._timing.accumulateTime(toString(), System.nanoTime() - t0);

                log.info(end, "' in ", Timing.toMillisPrint(System.nanoTime() - 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);

            final int functionLine = line;

            // 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), PROGRAM.symbolName()),

                new ArrayList<IdentNode>(),

                FunctionNode.Kind.NORMAL,

                functionLine);

            functionDeclarations = new ArrayList<>();

            sourceElements(false);

            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));

            printAST(function);

            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(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, final int functionLine) {

        // Build function name.

        final StringBuilder sb = new StringBuilder();

        final FunctionNode parentFunction = lc.getCurrentFunction();

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

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

        }

        assert ident.getName() != null;

        sb.append(ident.getName());

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

        assert parentFunction != null || name.equals(PROGRAM.symbolName()) || name.startsWith(RecompilableScriptFunctionData.RECOMPILATION_PREFIX) : "name = " + name;

        int flags = 0;

        if (isStrictMode) {

            flags |= FunctionNode.IS_STRICT;

        }

        if (parentFunction == null) {

            flags |= FunctionNode.IS_PROGRAM;

        }

        // Start new block.

        final FunctionNode functionNode =

            new FunctionNode(

                source,

                nextFunctionId++,

                functionLine,

                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.

     */