/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.

 * Use of this file is governed by the BSD 3-clause license that

 * can be found in the LICENSE.txt file in the project root.

 */

#pragma once

#include "Recognizer.h"

#include "tree/ParseTreeListener.h"

#include "tree/ParseTree.h"

#include "TokenStream.h"

#include "TokenSource.h"

#include "misc/Interval.h"

namespace antlr4 {

  /// This is all the parsing support code essentially; most of it is error recovery stuff.

  class ANTLR4CPP_PUBLIC Parser : public Recognizer {

  public:

    class TraceListener : public tree::ParseTreeListener {

    public:

      TraceListener(Parser *outerInstance);

      virtual ~TraceListener();

      virtual void enterEveryRule(ParserRuleContext *ctx) override;

      virtual void visitTerminal(tree::TerminalNode *node) override;

      virtual void visitErrorNode(tree::ErrorNode *node) override;

      virtual void exitEveryRule(ParserRuleContext *ctx) override;

    private:

      Parser *const outerInstance;

    };

    class TrimToSizeListener : public tree::ParseTreeListener {

    public:

      static TrimToSizeListener INSTANCE;

      virtual ~TrimToSizeListener();

      virtual void enterEveryRule(ParserRuleContext *ctx) override;

      virtual void visitTerminal(tree::TerminalNode *node) override;

      virtual void visitErrorNode(tree::ErrorNode *node) override;

      virtual void exitEveryRule(ParserRuleContext *ctx) override;

    };

    Parser(TokenStream *input);

    virtual ~Parser();

    /// reset the parser's state

    virtual void reset();

    /// <summary>

    /// Match current input symbol against {@code ttype}. If the symbol type

    /// matches, <seealso cref="ANTLRErrorStrategy#reportMatch"/> and <seealso cref="#consume"/> are

    /// called to complete the match process.

    ///

    /// If the symbol type does not match,

    /// <seealso cref="ANTLRErrorStrategy#recoverInline"/> is called on the current error

    /// strategy to attempt recovery. If <seealso cref="#getBuildParseTree"/> is

    /// {@code true} and the token index of the symbol returned by

    /// <seealso cref="ANTLRErrorStrategy#recoverInline"/> is -1, the symbol is added to

    /// the parse tree by calling {@link #createErrorNode(ParserRuleContext, Token)} then

    /// {@link ParserRuleContext#addErrorNode(ErrorNode)}.

    /// </summary>

    /// <param name="ttype"> the token type to match </param>

    /// <returns> the matched symbol </returns>

    /// <exception cref="RecognitionException"> if the current input symbol did not match

    /// {@code ttype} and the error strategy could not recover from the

    /// mismatched symbol </exception>

    virtual Token* match(size_t ttype);

    /// <summary>

    /// Match current input symbol as a wildcard. If the symbol type matches

    /// (i.e. has a value greater than 0), <seealso cref="ANTLRErrorStrategy#reportMatch"/>

    /// and <seealso cref="#consume"/> are called to complete the match process.

    /// <p/>

    /// If the symbol type does not match,

    /// <seealso cref="ANTLRErrorStrategy#recoverInline"/> is called on the current error

    /// strategy to attempt recovery. If <seealso cref="#getBuildParseTree"/> is

    /// {@code true} and the token index of the symbol returned by

    /// <seealso cref="ANTLRErrorStrategy#recoverInline"/> is -1, the symbol is added to

    /// the parse tree by calling <seealso cref="ParserRuleContext#addErrorNode"/>.

    /// </summary>

    /// <returns> the matched symbol </returns>

    /// <exception cref="RecognitionException"> if the current input symbol did not match

    /// a wildcard and the error strategy could not recover from the mismatched

    /// symbol </exception>

    virtual Token* matchWildcard();

    /// <summary>

    /// Track the <seealso cref="ParserRuleContext"/> objects during the parse and hook

    /// them up using the <seealso cref="ParserRuleContext#children"/> list so that it

    /// forms a parse tree. The <seealso cref="ParserRuleContext"/> returned from the start

    /// rule represents the root of the parse tree.

    /// <p/>

    /// Note that if we are not building parse trees, rule contexts only point

    /// upwards. When a rule exits, it returns the context but that gets garbage

    /// collected if nobody holds a reference. It points upwards but nobody

    /// points at it.

    /// <p/>

    /// When we build parse trees, we are adding all of these contexts to

    /// <seealso cref="ParserRuleContext#children"/> list. Contexts are then not candidates

    /// for garbage collection.

    /// </summary>

    virtual void setBuildParseTree(bool buildParseTrees);

    /// <summary>

    /// Gets whether or not a complete parse tree will be constructed while

    /// parsing. This property is {@code true} for a newly constructed parser.

    /// </summary>

    /// <returns> {@code true} if a complete parse tree will be constructed while

    /// parsing, otherwise {@code false} </returns>

    virtual bool getBuildParseTree();

    /// <summary>

    /// Trim the internal lists of the parse tree during parsing to conserve memory.

    /// This property is set to {@code false} by default for a newly constructed parser.

    /// </summary>

    /// <param name="trimParseTrees"> {@code true} to trim the capacity of the <seealso cref="ParserRuleContext#children"/>

    /// list to its size after a rule is parsed. </param>

    virtual void setTrimParseTree(bool trimParseTrees);

    /// <returns> {@code true} if the <seealso cref="ParserRuleContext#children"/> list is trimmed

    /// using the default <seealso cref="Parser.TrimToSizeListener"/> during the parse process. </returns>

    virtual bool getTrimParseTree();

    virtual std::vector<tree::ParseTreeListener *> getParseListeners();

    /// <summary>

    /// Registers {@code listener} to receive events during the parsing process.

    /// <p/>

    /// To support output-preserving grammar transformations (including but not

    /// limited to left-recursion removal, automated left-factoring, and

    /// optimized code generation), calls to listener methods during the parse

    /// may differ substantially from calls made by

    /// <seealso cref="ParseTreeWalker#DEFAULT"/> used after the parse is complete. In

    /// particular, rule entry and exit events may occur in a different order

    /// during the parse than after the parser. In addition, calls to certain

    /// rule entry methods may be omitted.

    /// <p/>

    /// With the following specific exceptions, calls to listener events are

    /// <em>deterministic</em>, i.e. for identical input the calls to listener

    /// methods will be the same.

    ///

    /// <ul>

    /// <li>Alterations to the grammar used to generate code may change the

    /// behavior of the listener calls.</li>

    /// <li>Alterations to the command line options passed to ANTLR 4 when

    /// generating the parser may change the behavior of the listener calls.</li>

    /// <li>Changing the version of the ANTLR Tool used to generate the parser

    /// may change the behavior of the listener calls.</li>

    /// </ul>

    /// </summary>

    /// <param name="listener"> the listener to add

    /// </param>

    /// <exception cref="NullPointerException"> if {@code} listener is {@code null} </exception>

    virtual void addParseListener(tree::ParseTreeListener *listener);

    /// <summary>

    /// Remove {@code listener} from the list of parse listeners.

    /// <p/>

    /// If {@code listener} is {@code null} or has not been added as a parse

    /// listener, this method does nothing.

    /// </summary>

    /// <seealso cref= #addParseListener

    /// </seealso>

    /// <param name="listener"> the listener to remove </param>

    virtual void removeParseListener(tree::ParseTreeListener *listener);

    /// <summary>

    /// Remove all parse listeners.

    /// </summary>

    /// <seealso cref= #addParseListener </seealso>

    virtual void removeParseListeners();

    /// <summary>

    /// Notify any parse listeners of an enter rule event.

    /// </summary>

    /// <seealso cref= #addParseListener </seealso>

    virtual void triggerEnterRuleEvent();

    /// <summary>

    /// Notify any parse listeners of an exit rule event.

    /// </summary>

    /// <seealso cref= #addParseListener </seealso>

    virtual void triggerExitRuleEvent();

    /// <summary>

    /// Gets the number of syntax errors reported during parsing. This value is

    /// incremented each time <seealso cref="#notifyErrorListeners"/> is called.

    /// </summary>

    /// <seealso cref= #notifyErrorListeners </seealso>

    virtual size_t getNumberOfSyntaxErrors();

    virtual TokenFactory<CommonToken>* getTokenFactory() override;

    /// <summary>

    /// Tell our token source and error strategy about a new way to create tokens. </summary>

    template<typename T1>

    void setTokenFactory(TokenFactory<T1> *factory)  {

      _input->getTokenSource()->setTokenFactory(factory);

    }

    /// The ATN with bypass alternatives is expensive to create so we create it

    /// lazily. The ATN is owned by us.

    virtual const atn::ATN& getATNWithBypassAlts();

    /// <summary>

    /// The preferred method of getting a tree pattern. For example, here's a

    /// sample use:

    ///

    /// <pre>

    /// ParseTree t = parser.expr();

    /// ParseTreePattern p = parser.compileParseTreePattern("<ID>+0", MyParser.RULE_expr);

    /// ParseTreeMatch m = p.match(t);

    /// String id = m.get("ID");

    /// </pre>

    /// </summary>

    virtual tree::pattern::ParseTreePattern compileParseTreePattern(const std::string &pattern, int patternRuleIndex);

    /// <summary>

    /// The same as <seealso cref="#compileParseTreePattern(String, int)"/> but specify a

    /// <seealso cref="Lexer"/> rather than trying to deduce it from this parser.

    /// </summary>

    virtual tree::pattern::ParseTreePattern compileParseTreePattern(const std::string &pattern, int patternRuleIndex,

                                                                    Lexer *lexer);

    virtual Ref<ANTLRErrorStrategy> getErrorHandler();

    virtual void setErrorHandler(Ref<ANTLRErrorStrategy> const& handler);

    virtual IntStream* getInputStream() override;

    void setInputStream(IntStream *input) override;

    virtual TokenStream* getTokenStream();

    /// Set the token stream and reset the parser.

    virtual void setTokenStream(TokenStream *input);

    /// <summary>

    /// Match needs to return the current input symbol, which gets put

    ///  into the label for the associated token ref; e.g., x=ID.

    /// </summary>

    virtual Token* getCurrentToken();

    void notifyErrorListeners(const std::string &msg);

    virtual void notifyErrorListeners(Token *offendingToken, const std::string &msg, std::exception_ptr e);

    /// Consume and return the <seealso cref="#getCurrentToken current symbol"/>.

    /// <p/>

    /// E.g., given the following input with {@code A} being the current

    /// lookahead symbol, this function moves the cursor to {@code B} and returns

    /// {@code A}.

    ///

    /// <pre>

    ///  A B

    ///  ^

    /// </pre>

    ///

    /// If the parser is not in error recovery mode, the consumed symbol is added

    /// to the parse tree using <seealso cref="ParserRuleContext#addChild(TerminalNode)"/>, and

    /// <seealso cref="ParseTreeListener#visitTerminal"/> is called on any parse listeners.

    /// If the parser <em>is</em> in error recovery mode, the consumed symbol is

    /// added to the parse tree using {@link #createErrorNode(ParserRuleContext, Token)} then

    /// {@link ParserRuleContext#addErrorNode(ErrorNode)} and

    /// <seealso cref="ParseTreeListener#visitErrorNode"/> is called on any parse

    /// listeners.

    virtual Token* consume();

    /// Always called by generated parsers upon entry to a rule. Access field

    /// <seealso cref="#_ctx"/> get the current context.

    virtual void enterRule(ParserRuleContext *localctx, size_t state, size_t ruleIndex);

    void exitRule();

    virtual void enterOuterAlt(ParserRuleContext *localctx, size_t altNum);

    /**

     * Get the precedence level for the top-most precedence rule.

     *

     * @return The precedence level for the top-most precedence rule, or -1 if

     * the parser context is not nested within a precedence rule.

     */

    int getPrecedence() const;

    /// @deprecated Use

    /// <seealso cref="#enterRecursionRule(ParserRuleContext, int, int, int)"/> instead.

    virtual void enterRecursionRule(ParserRuleContext *localctx, size_t ruleIndex);

    virtual void enterRecursionRule(ParserRuleContext *localctx, size_t state, size_t ruleIndex, int precedence);

    /** Like {@link #enterRule} but for recursive rules.

     *  Make the current context the child of the incoming localctx.

     */

    virtual void pushNewRecursionContext(ParserRuleContext *localctx, size_t state, size_t ruleIndex);

    virtual void unrollRecursionContexts(ParserRuleContext *parentctx);

    virtual ParserRuleContext* getInvokingContext(size_t ruleIndex);

    virtual ParserRuleContext* getContext();

    virtual void setContext(ParserRuleContext *ctx);

    virtual bool precpred(RuleContext *localctx, int precedence) override;

    virtual bool inContext(const std::string &context);

    /// <summary>

    /// Checks whether or not {@code symbol} can follow the current state in the

    /// ATN. The behavior of this method is equivalent to the following, but is

    /// implemented such that the complete context-sensitive follow set does not

    /// need to be explicitly constructed.

    ///

    /// <pre>

    /// return getExpectedTokens().contains(symbol);

    /// </pre>

    /// </summary>

    /// <param name="symbol"> the symbol type to check </param>

    /// <returns> {@code true} if {@code symbol} can follow the current state in

    /// the ATN, otherwise {@code false}. </returns>

    virtual bool isExpectedToken(size_t symbol);

    bool isMatchedEOF() const;

    /// <summary>

    /// Computes the set of input symbols which could follow the current parser

    /// state and context, as given by <seealso cref="#getState"/> and <seealso cref="#getContext"/>,

    /// respectively.

    /// </summary>

    /// <seealso cref= ATN#getExpectedTokens(int, RuleContext) </seealso>

    virtual misc::IntervalSet getExpectedTokens();

    virtual misc::IntervalSet getExpectedTokensWithinCurrentRule();

    /// Get a rule's index (i.e., {@code RULE_ruleName} field) or INVALID_INDEX if not found.

    virtual size_t getRuleIndex(const std::string &ruleName);

    virtual ParserRuleContext* getRuleContext();

    /// <summary>

    /// Return List<String> of the rule names in your parser instance

    ///  leading up to a call to the current rule.  You could override if

    ///  you want more details such as the file/line info of where

    ///  in the ATN a rule is invoked.

    ///

    ///  This is very useful for error messages.

    /// </summary>

    virtual std::vector<std::string> getRuleInvocationStack();

    virtual std::vector<std::string> getRuleInvocationStack(RuleContext *p);

    /// <summary>

    /// For debugging and other purposes. </summary>

    virtual std::vector<std::string> getDFAStrings();

    /// <summary>

    /// For debugging and other purposes. </summary>

    virtual void dumpDFA();

    virtual std::string getSourceName();

    atn::ParseInfo getParseInfo() const;

    /**

     * @since 4.3

     */

    void setProfile(bool profile);

    /// <summary>

    /// During a parse is sometimes useful to listen in on the rule entry and exit

    ///  events as well as token matches. This is for quick and dirty debugging.

    /// </summary>

    virtual void setTrace(bool trace);

    /**

     * Gets whether a {@link TraceListener} is registered as a parse listener

     * for the parser.

     *

     * @see #setTrace(boolean)

     */

    bool isTrace() const;

    tree::ParseTreeTracker& getTreeTracker() { return _tracker; }

    /** How to create a token leaf node associated with a parent.

     *  Typically, the terminal node to create is not a function of the parent

     *  but this method must still set the parent pointer of the terminal node

     *  returned. I would prefer having {@link ParserRuleContext#addAnyChild(ParseTree)}

     *  set the parent pointer, but the parent pointer is implementation dependent

     *  and currently there is no setParent() in {@link TerminalNode} (and can't

     *  add method in Java 1.7 without breaking backward compatibility).

     *

     * @since 4.7

     */

    tree::TerminalNode *createTerminalNode(Token *t);

    /** How to create an error node, given a token, associated with a parent.

       *  Typically, the error node to create is not a function of the parent

       *  but this method must still set the parent pointer of the terminal node

       *  returned. I would prefer having {@link ParserRuleContext#addAnyChild(ParseTree)}

       *  set the parent pointer, but the parent pointer is implementation dependent

       *  and currently there is no setParent() in {@link ErrorNode} (and can't

       *  add method in Java 1.7 without breaking backward compatibility).

       *

       * @since 4.7

       */

    tree::ErrorNode *createErrorNode(Token *t);

  protected:

    /// The ParserRuleContext object for the currently executing rule.

    /// This is always non-null during the parsing process.

    // ml: this is one of the contexts tracked in _allocatedContexts.

    ParserRuleContext *_ctx;

    /// The error handling strategy for the parser. The default is DefaultErrorStrategy.

    /// See also getErrorHandler.

    Ref<ANTLRErrorStrategy> _errHandler;

    /// <summary>

    /// The input stream.

    /// </summary>

    /// <seealso cref= #getInputStream </seealso>

    /// <seealso cref= #setInputStream </seealso>

    TokenStream *_input;

    std::vector<int> _precedenceStack;

    /// <summary>

    /// Specifies whether or not the parser should construct a parse tree during

    /// the parsing process. The default value is {@code true}.

    /// </summary>

    /// <seealso cref= #getBuildParseTree </seealso>

    /// <seealso cref= #setBuildParseTree </seealso>

    bool _buildParseTrees;

    /// The list of <seealso cref="ParseTreeListener"/> listeners registered to receive

    /// events during the parse.

    /// <seealso cref= #addParseListener </seealso>

    std::vector<tree::ParseTreeListener *> _parseListeners;

    /// <summary>

    /// The number of syntax errors reported during parsing. This value is

    /// incremented each time <seealso cref="#notifyErrorListeners"/> is called.

    /// </summary>

    size_t _syntaxErrors;

    /** Indicates parser has match()ed EOF token. See {@link #exitRule()}. */

    bool _matchedEOF;

    virtual void addContextToParseTree();

    // All rule contexts created during a parse run. This is cleared when calling reset().

    tree::ParseTreeTracker _tracker;

  private:

    /// When setTrace(true) is called, a reference to the

    /// TraceListener is stored here so it can be easily removed in a

    /// later call to setTrace(false). The listener itself is

    /// implemented as a parser listener so this field is not directly used by

    /// other parser methods.

    TraceListener *_tracer;

    void InitializeInstanceFields();

  };

} // namespace antlr4