/*

 * Copyright (c) 1999, 2012, 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 com.sun.tools.javac.parser;

import java.util.*;

import com.sun.source.tree.MemberReferenceTree.ReferenceMode;

import com.sun.tools.javac.code.*;

import com.sun.tools.javac.parser.Tokens.*;

import com.sun.tools.javac.parser.Tokens.Comment.CommentStyle;

import com.sun.tools.javac.tree.*;

import com.sun.tools.javac.tree.JCTree.*;

import com.sun.tools.javac.util.*;

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag;

import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;

import com.sun.tools.javac.util.List;

import static com.sun.tools.javac.parser.Tokens.TokenKind.*;

import static com.sun.tools.javac.parser.Tokens.TokenKind.ASSERT;

import static com.sun.tools.javac.parser.Tokens.TokenKind.CASE;

import static com.sun.tools.javac.parser.Tokens.TokenKind.CATCH;

import static com.sun.tools.javac.parser.Tokens.TokenKind.EQ;

import static com.sun.tools.javac.parser.Tokens.TokenKind.GT;

import static com.sun.tools.javac.parser.Tokens.TokenKind.IMPORT;

import static com.sun.tools.javac.parser.Tokens.TokenKind.LT;

import static com.sun.tools.javac.util.ListBuffer.lb;

import static com.sun.tools.javac.tree.JCTree.Tag.*;

/** The parser maps a token sequence into an abstract syntax

 *  tree. It operates by recursive descent, with code derived

 *  systematically from an LL(1) grammar. For efficiency reasons, an

 *  operator precedence scheme is used for parsing binary operation

 *  expressions.

 *

 *  <p><b>This is NOT part of any supported API.

 *  If you write code that depends on this, you do so at your own risk.

 *  This code and its internal interfaces are subject to change or

 *  deletion without notice.</b>

 */

public class JavacParser implements Parser {

    /** The number of precedence levels of infix operators.

     */

    private static final int infixPrecedenceLevels = 10;

    /** The scanner used for lexical analysis.

     */

    protected Lexer S;

    /** The factory to be used for abstract syntax tree construction.

     */

    protected TreeMaker F;

    /** The log to be used for error diagnostics.

     */

    private Log log;

    /** The Source language setting. */

    private Source source;

    /** The name table. */

    private Names names;

    /** End position mappings container */

    private final AbstractEndPosTable endPosTable;

    /** Construct a parser from a given scanner, tree factory and log.

     */

    protected JavacParser(ParserFactory fac,

                     Lexer S,

                     boolean keepDocComments,

                     boolean keepLineMap,

                     boolean keepEndPositions) {

        this.S = S;

        nextToken(); // prime the pump

        this.F = fac.F;

        this.log = fac.log;

        this.names = fac.names;

        this.source = fac.source;

        this.allowGenerics = source.allowGenerics();

        this.allowVarargs = source.allowVarargs();

        this.allowAsserts = source.allowAsserts();

        this.allowEnums = source.allowEnums();

        this.allowForeach = source.allowForeach();

        this.allowStaticImport = source.allowStaticImport();

        this.allowAnnotations = source.allowAnnotations();

        this.allowTWR = source.allowTryWithResources();

        this.allowDiamond = source.allowDiamond();

        this.allowMulticatch = source.allowMulticatch();

        this.allowStringFolding = fac.options.getBoolean("allowStringFolding", true);

        this.allowLambda = source.allowLambda() &&

                fac.options.isSet("allowLambda"); //pre-lambda guard

        this.allowMethodReferences = source.allowMethodReferences() &&

                fac.options.isSet("allowMethodReferences"); //pre-lambda guard

        this.keepDocComments = keepDocComments;

        docComments = newDocCommentTable(keepDocComments);

        this.keepLineMap = keepLineMap;

        this.errorTree = F.Erroneous();

        endPosTable = newEndPosTable(keepEndPositions);

    }

    protected AbstractEndPosTable newEndPosTable(boolean keepEndPositions) {

        return  keepEndPositions

                ? new SimpleEndPosTable()

                : new EmptyEndPosTable();

    }

    protected DocCommentTable newDocCommentTable(boolean keepDocComments) {

        return keepDocComments ? new SimpleDocCommentTable() : null;

    }

    /** Switch: Should generics be recognized?

     */

    boolean allowGenerics;

    /** Switch: Should diamond operator be recognized?

     */

    boolean allowDiamond;

    /** Switch: Should multicatch clause be accepted?

     */

    boolean allowMulticatch;

    /** Switch: Should varargs be recognized?

     */

    boolean allowVarargs;

    /** Switch: should we recognize assert statements, or just give a warning?

     */

    boolean allowAsserts;

    /** Switch: should we recognize enums, or just give a warning?

     */

    boolean allowEnums;

    /** Switch: should we recognize foreach?

     */

    boolean allowForeach;

    /** Switch: should we recognize foreach?

     */

    boolean allowStaticImport;

    /** Switch: should we recognize annotations?

     */

    boolean allowAnnotations;

    /** Switch: should we recognize try-with-resources?

     */

    boolean allowTWR;

    /** Switch: should we fold strings?

     */

    boolean allowStringFolding;

    /** Switch: should we recognize lambda expressions?

     */

    boolean allowLambda;

    /** Switch: should we allow method/constructor references?

     */

    boolean allowMethodReferences;

    /** Switch: should we keep docComments?

     */

    boolean keepDocComments;

    /** Switch: should we keep line table?

     */

    boolean keepLineMap;

    /** When terms are parsed, the mode determines which is expected:

     *     mode = EXPR        : an expression

     *     mode = TYPE        : a type

     *     mode = NOPARAMS    : no parameters allowed for type

     *     mode = TYPEARG     : type argument

     */

    static final int EXPR = 0x1;

    static final int TYPE = 0x2;

    static final int NOPARAMS = 0x4;

    static final int TYPEARG = 0x8;

    static final int DIAMOND = 0x10;

    /** The current mode.

     */

    private int mode = 0;

    /** The mode of the term that was parsed last.

     */

    private int lastmode = 0;

    /* ---------- token management -------------- */

    protected Token token;

    protected void nextToken() {

        S.nextToken();

        token = S.token();

    }

    protected boolean peekToken(TokenKind tk) {

        return S.token(1).kind == tk;

    }

    protected boolean peekToken(TokenKind tk1, TokenKind tk2) {

        return S.token(1).kind == tk1 &&

                S.token(2).kind == tk2;

    }

    protected boolean peekToken(TokenKind tk1, TokenKind tk2, TokenKind tk3) {

        return S.token(1).kind == tk1 &&

                S.token(2).kind == tk2 &&

                S.token(3).kind == tk3;

    }

    protected boolean peekToken(TokenKind... kinds) {

        for (int lookahead = 0 ; lookahead < kinds.length ; lookahead++) {

            if (S.token(lookahead + 1).kind != kinds[lookahead]) {

                return false;

            }

        }

        return true;

    }

    /* ---------- error recovery -------------- */

    private JCErroneous errorTree;

    /** Skip forward until a suitable stop token is found.

     */

    private void skip(boolean stopAtImport, boolean stopAtMemberDecl, boolean stopAtIdentifier, boolean stopAtStatement) {

         while (true) {

             switch (token.kind) {

                case SEMI:

                    nextToken();

                    return;

                case PUBLIC:

                case FINAL:

                case ABSTRACT:

                case MONKEYS_AT:

                case EOF:

                case CLASS:

                case INTERFACE:

                case ENUM:

                    return;

                case IMPORT:

                    if (stopAtImport)

                        return;

                    break;

                case LBRACE:

                case RBRACE:

                case PRIVATE:

                case PROTECTED:

                case STATIC:

                case TRANSIENT:

                case NATIVE:

                case VOLATILE:

                case SYNCHRONIZED:

                case STRICTFP:

                case LT:

                case BYTE:

                case SHORT:

                case CHAR:

                case INT:

                case LONG:

                case FLOAT:

                case DOUBLE:

                case BOOLEAN:

                case VOID:

                    if (stopAtMemberDecl)

                        return;

                    break;

                case IDENTIFIER:

                   if (stopAtIdentifier)

                        return;

                    break;

                case CASE:

                case DEFAULT:

                case IF:

                case FOR:

                case WHILE:

                case DO:

                case TRY:

                case SWITCH:

                case RETURN:

                case THROW:

                case BREAK:

                case CONTINUE:

                case ELSE:

                case FINALLY:

                case CATCH:

                    if (stopAtStatement)

                        return;

                    break;

            }

            nextToken();

        }

    }

    private JCErroneous syntaxError(int pos, String key, TokenKind... args) {

        return syntaxError(pos, List.<JCTree>nil(), key, args);

    }

    private JCErroneous syntaxError(int pos, List<JCTree> errs, String key, TokenKind... args) {

        setErrorEndPos(pos);

        JCErroneous err = F.at(pos).Erroneous(errs);

        reportSyntaxError(err, key, (Object[])args);

        if (errs != null) {

            JCTree last = errs.last();

            if (last != null)

                storeEnd(last, pos);

        }

        return toP(err);

    }

    private int errorPos = Position.NOPOS;

    /**

     * Report a syntax using the given the position parameter and arguments,

     * unless one was already reported at the same position.

     */

    private void reportSyntaxError(int pos, String key, Object... args) {

        JCDiagnostic.DiagnosticPosition diag = new JCDiagnostic.SimpleDiagnosticPosition(pos);

        reportSyntaxError(diag, key, args);

    }

    /**

     * Report a syntax error using the given DiagnosticPosition object and

     * arguments, unless one was already reported at the same position.

     */

    private void reportSyntaxError(JCDiagnostic.DiagnosticPosition diagPos, String key, Object... args) {

        int pos = diagPos.getPreferredPosition();

        if (pos > S.errPos() || pos == Position.NOPOS) {

            if (token.kind == EOF) {

                error(diagPos, "premature.eof");

            } else {

                error(diagPos, key, args);

            }

        }

        S.errPos(pos);

        if (token.pos == errorPos)

            nextToken(); // guarantee progress

        errorPos = token.pos;

    }

    /** Generate a syntax error at current position unless one was already

     *  reported at the same position.

     */

    private JCErroneous syntaxError(String key) {

        return syntaxError(token.pos, key);

    }

    /** Generate a syntax error at current position unless one was

     *  already reported at the same position.

     */

    private JCErroneous syntaxError(String key, TokenKind arg) {

        return syntaxError(token.pos, key, arg);

    }

    /** If next input token matches given token, skip it, otherwise report

     *  an error.

     */

    public void accept(TokenKind tk) {

        if (token.kind == tk) {

            nextToken();

        } else {

            setErrorEndPos(token.pos);

            reportSyntaxError(S.prevToken().endPos, "expected", tk);

        }

    }

    /** Report an illegal start of expression/type error at given position.

     */

    JCExpression illegal(int pos) {

        setErrorEndPos(pos);

        if ((mode & EXPR) != 0)

            return syntaxError(pos, "illegal.start.of.expr");

        else

            return syntaxError(pos, "illegal.start.of.type");

    }

    /** Report an illegal start of expression/type error at current position.

     */

    JCExpression illegal() {

        return illegal(token.pos);

    }

    /** Diagnose a modifier flag from the set, if any. */

    void checkNoMods(long mods) {

        if (mods != 0) {

            long lowestMod = mods & -mods;

            error(token.pos, "mod.not.allowed.here",

                      Flags.asFlagSet(lowestMod));

        }

    }

/* ---------- doc comments --------- */

    /** A table to store all documentation comments

     *  indexed by the tree nodes they refer to.

     *  defined only if option flag keepDocComment is set.

     */

    private final DocCommentTable docComments;

    /** Make an entry into docComments hashtable,

     *  provided flag keepDocComments is set and given doc comment is non-null.

     *  @param tree   The tree to be used as index in the hashtable

     *  @param dc     The doc comment to associate with the tree, or null.

     */

    void attach(JCTree tree, Comment dc) {

        if (keepDocComments && dc != null) {

//          System.out.println("doc comment = ");System.out.println(dc);//DEBUG

            docComments.putComment(tree, dc);

        }

    }

/* -------- source positions ------- */

    private void setErrorEndPos(int errPos) {

        endPosTable.setErrorEndPos(errPos);

    }

    private void storeEnd(JCTree tree, int endpos) {

        endPosTable.storeEnd(tree, endpos);

    }

    private <T extends JCTree> T to(T t) {

        return endPosTable.to(t);

    }

    private <T extends JCTree> T toP(T t) {

        return endPosTable.toP(t);

    }

    /** Get the start position for a tree node.  The start position is

     * defined to be the position of the first character of the first

     * token of the node's source text.

     * @param tree  The tree node

     */

    public int getStartPos(JCTree tree) {

        return TreeInfo.getStartPos(tree);

    }

    /**

     * Get the end position for a tree node.  The end position is

     * defined to be the position of the last character of the last

     * token of the node's source text.  Returns Position.NOPOS if end

     * positions are not generated or the position is otherwise not

     * found.

     * @param tree  The tree node

     */

    public int getEndPos(JCTree tree) {

        return endPosTable.getEndPos(tree);

    }

/* ---------- parsing -------------- */

    /**

     * Ident = IDENTIFIER

     */

    Name ident() {

        if (token.kind == IDENTIFIER) {

            Name name = token.name();

            nextToken();

            return name;

        } else if (token.kind == ASSERT) {

            if (allowAsserts) {

                error(token.pos, "assert.as.identifier");

                nextToken();

                return names.error;

            } else {

                warning(token.pos, "assert.as.identifier");

                Name name = token.name();

                nextToken();

                return name;

            }

        } else if (token.kind == ENUM) {

            if (allowEnums) {