/*

 * Copyright (c) 1999, 2011, 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.tools.javac.tree.*;

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

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

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

import static com.sun.tools.javac.parser.Token.*;

/** 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 keyword table. */

    private Keywords keywords;

    /** The Source language setting. */

    private Source source;

    /** The name table. */

    private Names names;

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

     */

    protected JavacParser(ParserFactory fac,

                     Lexer S,

                     boolean keepDocComments,

                     boolean keepLineMap) {

        this.S = S;

        S.nextToken(); // prime the pump

        this.F = fac.F;

        this.log = fac.log;

        this.names = fac.names;

        this.keywords = fac.keywords;

        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.keepDocComments = keepDocComments;

        docComments = keepDocComments ? new HashMap<JCTree,String>() : null;

        this.keepLineMap = keepLineMap;

        this.errorTree = F.Erroneous();

    }

    /** 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 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;

/* ---------- 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 (S.token()) {

                case SEMI:

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

            }

            S.nextToken();

        }

    }

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

    }

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

        setErrorEndPos(pos);

    }

    private int errorPos = Position.NOPOS;

    /**

     */

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

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

        }

        S.errPos(pos);

        if (S.pos() == errorPos)

            S.nextToken(); // guarantee progress

        errorPos = S.pos();

    }

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

     *  reported at the same position.

     */

    private JCErroneous syntaxError(String key) {

        return syntaxError(S.pos(), key);

    }

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

     *  already reported at the same position.

     */

    private JCErroneous syntaxError(String key, Token arg) {

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

    }

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

     *  an error.

     */

    public void accept(Token token) {

        if (S.token() == token) {

            S.nextToken();

        } else {

            setErrorEndPos(S.pos());

            reportSyntaxError(S.prevEndPos(), "expected", token);

        }

    }

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

     */

    JCExpression illegal(int 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(S.pos());

    }

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

    void checkNoMods(long mods) {

        if (mods != 0) {

            long lowestMod = mods & -mods;

            error(S.pos(), "mod.not.allowed.here",

                      Flags.asFlagSet(lowestMod));

        }

    }

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

    /** A hashtable to store all documentation comments

     *  indexed by the tree nodes they refer to.

     *  defined only if option flag keepDocComment is set.

     */

    /** 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, String dc) {

        if (keepDocComments && dc != null) {

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

            docComments.put(tree, dc);

        }

    }

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

    private int errorEndPos = -1;

    private void setErrorEndPos(int errPos) {

        if (errPos > errorEndPos)

            errorEndPos = errPos;

    }

    protected int getErrorEndPos() {

        return errorEndPos;

    }

    /**

     * Store ending position for a tree.

     * @param tree   The tree.

     * @param endpos The ending position to associate with the tree.

     */

    protected void storeEnd(JCTree tree, int endpos) {}

    /**

     * Store ending position for a tree.  The ending position should

     * be the ending position of the current token.

     * @param t The tree.

     */

    protected <T extends JCTree> T to(T t) { return t; }

    /**

     * Store ending position for a tree.  The ending position should

     * be greater of the ending position of the previous token and errorEndPos.

     * @param t The tree.

     */

    protected <T extends JCTree> T toP(T t) { return 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 Position.NOPOS;

    }

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

    /**

     * Ident = IDENTIFIER

     */

    Name ident() {

        if (S.token() == IDENTIFIER) {

            Name name = S.name();

            S.nextToken();

            return name;

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

            if (allowAsserts) {

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

                S.nextToken();

                return names.error;

            } else {

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

                Name name = S.name();

                S.nextToken();

                return name;

            }

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

            if (allowEnums) {

                error(S.pos(), "enum.as.identifier");

                S.nextToken();

                return names.error;

            } else {

                warning(S.pos(), "enum.as.identifier");

                Name name = S.name();

                S.nextToken();

                return name;

            }

        } else {

            accept(IDENTIFIER);

            return names.error;

        }

}

    /**

     * Qualident = Ident { DOT Ident }

     */

    public JCExpression qualident() {

        JCExpression t = toP(F.at(S.pos()).Ident(ident()));

        while (S.token() == DOT) {

            int pos = S.pos();

            S.nextToken();

            t = toP(F.at(pos).Select(t, ident()));

        }

        return t;

    }

    /**

     * Literal =

     *     INTLITERAL

     *   | LONGLITERAL

     *   | FLOATLITERAL

     *   | DOUBLELITERAL

     *   | CHARLITERAL

     *   | STRINGLITERAL

     *   | TRUE

     *   | FALSE

     *   | NULL

     */

        JCExpression t = errorTree;

        switch (S.token()) {

        case INTLITERAL:

            try {

                t = F.at(pos).Literal(

                    TypeTags.INT,

                    Convert.string2int(strval(prefix), S.radix()));

            } catch (NumberFormatException ex) {

                error(S.pos(), "int.number.too.large", strval(prefix));

            }

            break;

        case LONGLITERAL:

            try {

                t = F.at(pos).Literal(

                    TypeTags.LONG,

                    new Long(Convert.string2long(strval(prefix), S.radix())));

            } catch (NumberFormatException ex) {