cpp/third_party/antlr4-cpp-runtime-4/runtime/src/Parser.h - tsfile - Git at Google

 /* 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&lt;String&gt; 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:
     /// This field maps from the serialized ATN string to the deserialized <seealso cref="ATN"/> with
     /// bypass alternatives.
     ///
     /// <seealso cref= ATNDeserializationOptions#isGenerateRuleBypassTransitions() </seealso>
     static std::map<std::vector<uint16_t>, atn::ATN> bypassAltsAtnCache;

     /// 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
	/* 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:
	/// This field maps from the serialized ATN string to the deserialized <seealso cref="ATN"/> with
	/// bypass alternatives.
	///
	/// <seealso cref= ATNDeserializationOptions#isGenerateRuleBypassTransitions() </seealso>
	static std::map<std::vector<uint16_t>, atn::ATN> bypassAltsAtnCache;

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