/*

 * Copyright (c) 1999, 2009, 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.code.*;

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

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

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

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

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.

     */

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

    // Because of javac's limited lookahead, some contexts are ambiguous in

    // the presence of type annotations even though they are not ambiguous

    // in the absence of type annotations.  Consider this code:

    //   void m(String [] m) { }

    //   void m(String ... m) { }

    // After parsing "String", javac calls bracketsOpt which immediately

    // returns if the next character is not '['.  Similarly, javac can see

    // if the next token is ... and in that case parse an ellipsis.  But in

    // the presence of type annotations:

    //   void m(String @A [] m) { }

    //   void m(String @A ... m) { }

    // no finite lookahead is enough to determine whether to read array

    // levels or an ellipsis.  Furthermore, if you call bracketsOpt, then

    // bracketsOpt first reads all the leading annotations and only then

    // discovers that it needs to fail.  bracketsOpt needs a way to push

    // back the extra annotations that it read.  (But, bracketsOpt should

    // not *always* be allowed to push back extra annotations that it finds

    // -- in most contexts, any such extra annotation is an error.

    // Another similar case occurs with arrays and receiver annotations:

    //   String b() @Array [] @Receiver { }

    //   String b() @Receiver { }

    //

    // The following two variables permit type annotations that have

    // already been read to be stored for later use.  Alternate

    // implementations are possible but would cause much larger changes to

    // the parser.

    /** Type annotations that have already been read but have not yet been used. **/

    private List<JCTypeAnnotation> typeAnnotationsPushedBack = null;

    /**

     * If the parser notices extra annotations, then it either immediately

     * issues an error (if this variable is false) or places the extra

     * annotations in variable typeAnnotationsPushedBack (if this variable

     * is true).

     */

    private boolean permitTypeAnnotationsPushBack = false;

    /** 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.allowTypeAnnotations = source.allowTypeAnnotations();

        this.keepDocComments = keepDocComments;

        if (keepDocComments)

            docComments = new HashMap<JCTree,String>();

        this.keepLineMap = keepLineMap;

        this.errorTree = F.Erroneous();

        this.debugJSR308 = fac.options.get("TA:parser") != null;

    }

    /** Switch: debug output for type-annotations operations

     */

    boolean debugJSR308;

    /** 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 type annotations?

     */

    boolean allowTypeAnnotations;

    /** Switch: should we recognize automatic resource management?

     */

    boolean allowTWR;

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

        return syntaxError(pos, null, key, args);

    }

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

        setErrorEndPos(pos);

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

        return toP(F.at(pos).Erroneous(errs));

    }

    private int errorPos = Position.NOPOS;

    /**

     * Report a syntax error at given position using the given

     * argument unless one was already reported at the same position.

     */

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

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

            if (S.token() == EOF)

                log.error(pos, "premature.eof");

            else

                log.error(pos, key, args);

        }

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

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

            log.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.

     */

    Map<JCTree, String> 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, 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) {

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

                S.nextToken();

                return names.error;

            } else {

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

                Name name = S.name();

                S.nextToken();

                return name;

            }

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

            if (allowEnums) {

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

                S.nextToken();

                return names.error;

            } else {

                log.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 literal(Name prefix) {